Refactor telemetry constants

Author: chillaq

splitio/api/auth.py

@@ -4,7 +4,8 @@
 import json
 
 from splitio.api import APIException
-from splitio.api.commons import headers_from_metadata, record_telemetry, get_current_epoch_time
+from splitio.api.commons import headers_from_metadata, record_telemetry
+from splitio.util.time import get_current_epoch_time
 from splitio.api.client import HttpClientException
 from splitio.models.token import from_raw
 from splitio.models.telemetry import HTTPExceptionsAndLatencies
@@ -46,7 +47,7 @@ def authenticate(self):
                 self._apikey,
                 extra_headers=self._metadata,
             )
-            record_telemetry(response.status_code, get_current_epoch_time() - start, HTTPExceptionsAndLatencies.TOKEN.value, self._telemetry_runtime_producer)
+            record_telemetry(response.status_code, get_current_epoch_time() - start, HTTPExceptionsAndLatencies.TOKEN, self._telemetry_runtime_producer)
             if 200 <= response.status_code < 300:
                 payload = json.loads(response.body)
                 return from_raw(payload)

splitio/api/commons.py

@@ -1,5 +1,5 @@
 """Commons module."""
-import time
+from splitio.util.time import get_current_epoch_time
 
 _CACHE_CONTROL = 'Cache-Control'
 _CACHE_CONTROL_NO_CACHE = 'no-cache'
@@ -113,13 +113,4 @@ def build_fetch(change_number, fetch_options, metadata):
         extra_headers[_CACHE_CONTROL] = _CACHE_CONTROL_NO_CACHE
     if fetch_options.change_number is not None:
         query['till'] = fetch_options.change_number
-    return query, extra_headers
-
-def get_current_epoch_time():
-    """
-    Get current epoch time in milliseconds
-
-    :return: epoch time
-    :rtype: int
-    """
-    return int(round(time.time() * 1000))
+    return query, extra_headers

splitio/api/events.py

@@ -4,7 +4,8 @@
 
 from splitio.api import APIException
 from splitio.api.client import HttpClientException
-from splitio.api.commons import headers_from_metadata, record_telemetry, get_current_epoch_time
+from splitio.api.commons import headers_from_metadata, record_telemetry
+from splitio.util.time import get_current_epoch_time
 from splitio.models.telemetry import HTTPExceptionsAndLatencies
 
 
@@ -73,7 +74,7 @@ def flush_events(self, events):
                 body=bulk,
                 extra_headers=self._metadata,
             )
-            record_telemetry(response.status_code, get_current_epoch_time() - start, HTTPExceptionsAndLatencies.EVENT.value, self._telemetry_runtime_producer)
+            record_telemetry(response.status_code, get_current_epoch_time() - start, HTTPExceptionsAndLatencies.EVENT, self._telemetry_runtime_producer)
             if not 200 <= response.status_code < 300:
                 raise APIException(response.body, response.status_code)
         except HttpClientException as exc:

splitio/api/impressions.py

@@ -5,7 +5,8 @@
 
 from splitio.api import APIException
 from splitio.api.client import HttpClientException
-from splitio.api.commons import headers_from_metadata, record_telemetry, get_current_epoch_time
+from splitio.api.commons import headers_from_metadata, record_telemetry
+from splitio.util.time import get_current_epoch_time
 from splitio.engine.impressions import ImpressionsMode
 from splitio.models.telemetry import HTTPExceptionsAndLatencies
 
@@ -102,7 +103,7 @@ def flush_impressions(self, impressions):
                 body=bulk,
                 extra_headers=self._metadata,
             )
-            record_telemetry(response.status_code, get_current_epoch_time() - start, HTTPExceptionsAndLatencies.IMPRESSION.value, self._telemetry_runtime_producer)
+            record_telemetry(response.status_code, get_current_epoch_time() - start, HTTPExceptionsAndLatencies.IMPRESSION, self._telemetry_runtime_producer)
             if not 200 <= response.status_code < 300:
                 raise APIException(response.body, response.status_code)
         except HttpClientException as exc:
@@ -129,7 +130,7 @@ def flush_counters(self, counters):
                 body=bulk,
                 extra_headers=self._metadata,
             )
-            record_telemetry(response.status_code, get_current_epoch_time() - start, HTTPExceptionsAndLatencies.IMPRESSION_COUNT.value, self._telemetry_runtime_producer)
+            record_telemetry(response.status_code, get_current_epoch_time() - start, HTTPExceptionsAndLatencies.IMPRESSION_COUNT, self._telemetry_runtime_producer)
             if not 200 <= response.status_code < 300:
                 raise APIException(response.body, response.status_code)
         except HttpClientException as exc:

splitio/api/segments.py

@@ -5,7 +5,8 @@
 import time
 
 from splitio.api import APIException
-from splitio.api.commons import headers_from_metadata, build_fetch, record_telemetry, get_current_epoch_time
+from splitio.api.commons import headers_from_metadata, build_fetch, record_telemetry
+from splitio.util.time import get_current_epoch_time
 from splitio.api.client import HttpClientException
 from splitio.models.telemetry import HTTPExceptionsAndLatencies
 
@@ -59,7 +60,7 @@ def fetch_segment(self, segment_name, change_number, fetch_options):
                 extra_headers=extra_headers,
                 query=query,
             )
-            record_telemetry(response.status_code, get_current_epoch_time() - start, HTTPExceptionsAndLatencies.SEGMENT.value, self._telemetry_runtime_producer)
+            record_telemetry(response.status_code, get_current_epoch_time() - start, HTTPExceptionsAndLatencies.SEGMENT, self._telemetry_runtime_producer)
             if 200 <= response.status_code < 300:
                 return json.loads(response.body)
             else:

splitio/api/splits.py

@@ -5,7 +5,8 @@
 import time
 
 from splitio.api import APIException
-from splitio.api.commons import headers_from_metadata, build_fetch, record_telemetry, get_current_epoch_time
+from splitio.api.commons import headers_from_metadata, build_fetch, record_telemetry
+from splitio.util.time import get_current_epoch_time
 from splitio.api.client import HttpClientException
 from splitio.models.telemetry import HTTPExceptionsAndLatencies
 
@@ -54,7 +55,7 @@ def fetch_splits(self, change_number, fetch_options):
                 extra_headers=extra_headers,
                 query=query,
             )
-            record_telemetry(response.status_code, get_current_epoch_time() - start, HTTPExceptionsAndLatencies.SPLIT.value, self._telemetry_runtime_producer)
+            record_telemetry(response.status_code, get_current_epoch_time() - start, HTTPExceptionsAndLatencies.SPLIT, self._telemetry_runtime_producer)
             if 200 <= response.status_code < 300:
                 return json.loads(response.body)
             else:

splitio/api/telemetry.py

@@ -4,7 +4,8 @@
 
 from splitio.api import APIException
 from splitio.api.client import HttpClientException
-from splitio.api.commons import headers_from_metadata, record_telemetry, get_current_epoch_time
+from splitio.api.commons import headers_from_metadata, record_telemetry
+from splitio.util.time import get_current_epoch_time
 from splitio.models.telemetry import HTTPExceptionsAndLatencies
 
 _LOGGER = logging.getLogger(__name__)
@@ -42,7 +43,7 @@ def record_unique_keys(self, uniques):
                 body=uniques,
                 extra_headers=self._metadata
             )
-            record_telemetry(response.status_code,  get_current_epoch_time() - start, HTTPExceptionsAndLatencies.TELEMETRY.value, self._telemetry_runtime_producer)
+            record_telemetry(response.status_code,  get_current_epoch_time() - start, HTTPExceptionsAndLatencies.TELEMETRY, self._telemetry_runtime_producer)
             if not 200 <= response.status_code < 300:
                 raise APIException(response.body, response.status_code)
         except HttpClientException as exc:
@@ -68,7 +69,7 @@ def record_init(self, configs):
                 body=configs,
                 extra_headers=self._metadata,
             )
-            record_telemetry(response.status_code, get_current_epoch_time() - start, HTTPExceptionsAndLatencies.TELEMETRY.value, self._telemetry_runtime_producer)
+            record_telemetry(response.status_code, get_current_epoch_time() - start, HTTPExceptionsAndLatencies.TELEMETRY, self._telemetry_runtime_producer)
             if not 200 <= response.status_code < 300:
                 raise APIException(response.body, response.status_code)
         except HttpClientException as exc:
@@ -94,7 +95,7 @@ def record_stats(self, stats):
                 body=stats,
                 extra_headers=self._metadata,
             )
-            record_telemetry(response.status_code, get_current_epoch_time() - start, HTTPExceptionsAndLatencies.TELEMETRY.value, self._telemetry_runtime_producer)
+            record_telemetry(response.status_code, get_current_epoch_time() - start, HTTPExceptionsAndLatencies.TELEMETRY, self._telemetry_runtime_producer)
             if not 200 <= response.status_code < 300:
                 raise APIException(response.body, response.status_code)
         except HttpClientException as exc:

splitio/client/client.py

@@ -7,8 +7,7 @@
 from splitio.models.events import Event, EventWrapper
 from splitio.models.telemetry import get_latency_bucket_index, MethodExceptionsAndLatencies
 from splitio.client import input_validator
-from splitio.util import utctime_ms
-from splitio.api.commons import get_current_epoch_time
+from splitio.util.time import get_current_epoch_time, utctime_ms
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -124,7 +123,7 @@ def _make_evaluation(self, key, feature, attributes, method_name, metric_name):
         except Exception:  # pylint: disable=broad-except
             _LOGGER.error('Error getting treatment for feature')
             _LOGGER.debug('Error: ', exc_info=True)
-            self._telemetry_evaluation_producer.record_exception(method_name[4:])
+            self._telemetry_evaluation_producer.record_exception(self._get_method_constant(method_name[4:]))
             try:
                 impression = self._build_impression(
                     matching_key,
@@ -207,12 +206,12 @@ def _make_evaluations(self, key, features, attributes, method_name, metric_name)
                 _LOGGER.error('%s: An exception when trying to store '
                               'impressions.' % method_name)
                 _LOGGER.debug('Error: ', exc_info=True)
-                self._telemetry_evaluation_producer.record_exception(method_name[4:])
+                self._telemetry_evaluation_producer.record_exception(self._get_method_constant(method_name[4:]))
 
-            self._telemetry_evaluation_producer.record_latency(method_name[4:], get_current_epoch_time() - start)
+            self._telemetry_evaluation_producer.record_latency(self._get_method_constant(method_name[4:]), get_current_epoch_time() - start)
             return treatments
         except Exception:  # pylint: disable=broad-except
-            self._telemetry_evaluation_producer.record_exception(method_name[4:])
+            self._telemetry_evaluation_producer.record_exception(self._get_method_constant(method_name[4:]))
             _LOGGER.error('Error getting treatment for features')
             _LOGGER.debug('Error: ', exc_info=True)
         return input_validator.generate_control_treatments(list(features), method_name)
@@ -350,8 +349,8 @@ def _record_stats(self, impressions, start, operation, method_name=None):
         end = get_current_epoch_time()
         self._recorder.record_treatment_stats(impressions, get_latency_bucket_index(end - start),
                                               operation)
-        if not method_name == None:
-            self._telemetry_evaluation_producer.record_latency(method_name[4:], end - start)
+        if method_name is not None:
+            self._telemetry_evaluation_producer.record_latency(self._get_method_constant(method_name[4:]), end - start)
 
 
     def track(self, key, traffic_type, event_type, value=None, properties=None):
@@ -413,10 +412,20 @@ def track(self, key, traffic_type, event_type, value=None, properties=None):
                 event=event,
                 size=size,
             )])
-            self._telemetry_evaluation_producer.record_latency(MethodExceptionsAndLatencies.TRACK.value, get_current_epoch_time() - start)
+            self._telemetry_evaluation_producer.record_latency(MethodExceptionsAndLatencies.TRACK, get_current_epoch_time() - start)
+            return return_flag
         except Exception:  # pylint: disable=broad-except
-            self._telemetry_evaluation_producer.record_exception(MethodExceptionsAndLatencies.TRACK.value)
+            self._telemetry_evaluation_producer.record_exception(MethodExceptionsAndLatencies.TRACK)
             _LOGGER.error('Error processing track event')
             _LOGGER.debug('Error: ', exc_info=True)
+            return False
 
-        return return_flag
+    def _get_method_constant(self, method):
+        if method == 'treatment':
+            return MethodExceptionsAndLatencies.TREATMENT
+        elif method == 'treatments':
+            return MethodExceptionsAndLatencies.TREATMENTS
+        elif method == 'treatment_with_config':
+            return MethodExceptionsAndLatencies.TREATMENT_WITH_CONFIG
+        elif method == 'treatments_with_config':
+            return MethodExceptionsAndLatencies.TREATMENTS_WITH_CONFIG

splitio/client/factory.py

@@ -33,7 +33,7 @@
 from splitio.api.events import EventsAPI
 from splitio.api.auth import AuthAPI
 from splitio.api.telemetry import TelemetryAPI, LocalhostTelemetryAPI
-from splitio.api.commons import get_current_epoch_time
+from splitio.util.time import get_current_epoch_time
 
 # Tasks
 from splitio.tasks.split_sync import SplitSynchronizationTask
@@ -511,7 +511,7 @@ def _build_localhost_factory(cfg):
     telemetry_storage = LocalhostTelemetryStorage()
     telemetry_producer = TelemetryStorageProducer(telemetry_storage)
     telemetry_consumer = TelemetryStorageConsumer(telemetry_storage)
-    telemetry_runtime_producer=telemetry_producer.get_telemetry_runtime_producer()
+    telemetry_runtime_producer = telemetry_producer.get_telemetry_runtime_producer()
 
     storages = {
         'splits': InMemorySplitStorage(),
@@ -535,7 +535,7 @@ def _build_localhost_factory(cfg):
     sdk_metadata = util.get_metadata(cfg)
     ready_event = threading.Event()
     synchronizer = LocalhostSynchronizer(synchronizers, tasks)
-    manager = Manager(ready_event, synchronizer, None, False, sdk_metadata)
+    manager = Manager(ready_event, synchronizer, None, False, sdk_metadata, telemetry_runtime_producer)
     manager.start()
     recorder = StandardRecorder(
         ImpressionsManager(StrategyDebugMode(), telemetry_runtime_producer),

splitio/engine/impressions/impressions.py

@@ -2,6 +2,7 @@
 from enum import Enum
 
 from splitio.client.listener import ImpressionListenerException
+from splitio.models import telemetry
 
 class ImpressionsMode(Enum):
     """Impressions tracking mode."""
@@ -39,7 +40,7 @@ def process_impressions(self, impressions):
         """
         for_log, for_listener = self._strategy.process_impressions(impressions)
         if len(impressions) > len(for_log):
-            self._telemetry_runtime_producer.record_impression_stats('impressionsDeduped', len(impressions) - len(for_log))
+            self._telemetry_runtime_producer.record_impression_stats(telemetry.CounterConstants.IMPRESSIONS_DEDUPED, len(impressions) - len(for_log))
         self._send_impressions_to_listener(for_listener)
         return for_log