Telemetry api refactor and clenaup

Author: chillaq

splitio/api/auth.py

@@ -2,20 +2,21 @@
 
 import logging
 import json
+import time
 
 from splitio.api import APIException
-from splitio.api.commons import headers_from_metadata
+from splitio.api.commons import headers_from_metadata, record_telemetry
 from splitio.api.client import HttpClientException
 from splitio.models.token import from_raw
-
+from splitio.models.telemetry import TOKEN
 
 _LOGGER = logging.getLogger(__name__)
 
 
 class AuthAPI(object):  # pylint: disable=too-few-public-methods
     """Class that uses an httpClient to communicate with the SDK Auth Service API."""
 
-    def __init__(self, client, apikey, sdk_metadata):
+    def __init__(self, client, apikey, sdk_metadata, telemetry_runtime_producer):
         """
         Class constructor.
 
@@ -29,6 +30,7 @@ def __init__(self, client, apikey, sdk_metadata):
         self._client = client
         self._apikey = apikey
         self._metadata = headers_from_metadata(sdk_metadata)
+        self._telemetry_runtime_producer = telemetry_runtime_producer
 
     def authenticate(self):
         """
@@ -37,18 +39,21 @@ def authenticate(self):
         :return: Json representation of an authentication.
         :rtype: splitio.models.token.Token
         """
+        start = int(round(time.time() * 1000))
         try:
             response = self._client.get(
                 'auth',
                 '/v2/auth',
                 self._apikey,
                 extra_headers=self._metadata,
-                metric_name='token'
             )
+            record_telemetry(response.status_code, int(round(time.time() * 1000)) - start, TOKEN, self._telemetry_runtime_producer)
             if 200 <= response.status_code < 300:
                 payload = json.loads(response.body)
                 return from_raw(payload)
             else:
+                if response.status_code == 401:
+                    self._telemetry_runtime_producer.record_auth_rejections()
                 raise APIException(response.body, response.status_code)
         except HttpClientException as exc:
             _LOGGER.error('Exception raised while authenticating')

splitio/api/client.py

@@ -27,7 +27,7 @@ class HttpClient(object):
     AUTH_URL = 'https://auth.split.io/api'
     TELEMETRY_URL = 'https://telemetry.split.io/api'
 
-    def __init__(self, timeout=None, sdk_url=None, events_url=None, auth_url=None, telemetry_url=None, telemetry_runtime_producer=None):
+    def __init__(self, timeout=None, sdk_url=None, events_url=None, auth_url=None, telemetry_url=None):
         """
         Class constructor.
 
@@ -49,7 +49,6 @@ def __init__(self, timeout=None, sdk_url=None, events_url=None, auth_url=None, t
             'auth': auth_url if auth_url is not None else self.AUTH_URL,
             'telemetry': telemetry_url if telemetry_url is not None else self.TELEMETRY_URL,
         }
-        self._telemetry_runtime_producer = telemetry_runtime_producer
 
     def _build_url(self, server, path):
         """
@@ -78,7 +77,7 @@ def _build_basic_headers(apikey):
             'Authorization': "Bearer %s" % apikey
         }
 
-    def get(self, server, path, apikey, query=None, extra_headers=None, metric_name=None):  # pylint: disable=too-many-arguments
+    def get(self, server, path, apikey, query=None, extra_headers=None):  # pylint: disable=too-many-arguments
         """
         Issue a get request.
 
@@ -107,22 +106,12 @@ def get(self, server, path, apikey, query=None, extra_headers=None, metric_name=
                 headers=headers,
                 timeout=self._timeout
             )
-            elapsed = response.elapsed.total_seconds()
             response = HttpResponse(response.status_code, response.text)
-            self._telemetry_runtime_producer.record_sync_latency(metric_name, elapsed)
-            if not 200 <= response.status_code < 300:
-                self._telemetry_runtime_producer.record_sync_error(metric_name, response.status_code)
-                if metric_name == 'token':
-                    self._telemetry_runtime_producer.record_auth_rejections()
-            else:
-                self._telemetry_runtime_producer.record_suceessful_sync(metric_name, round(1000 * elapsed))
-                if metric_name == 'token':
-                    self._telemetry_runtime_producer.record_token_refreshes()
             return response
         except Exception as exc:  # pylint: disable=broad-except
             raise HttpClientException('requests library is throwing exceptions') from exc
 
-    def post(self, server, path, apikey, body, query=None, extra_headers=None, metric_name=None):  # pylint: disable=too-many-arguments
+    def post(self, server, path, apikey, body, query=None, extra_headers=None):  # pylint: disable=too-many-arguments
         """
         Issue a POST request.
 
@@ -155,13 +144,7 @@ def post(self, server, path, apikey, body, query=None, extra_headers=None, metri
                 headers=headers,
                 timeout=self._timeout
             )
-            elapsed = response.elapsed.total_seconds()
             response = HttpResponse(response.status_code, response.text)
-            self._telemetry_runtime_producer.record_sync_latency(metric_name, elapsed)
-            if not 200 <= response.status_code < 300:
-                self._telemetry_runtime_producer.record_sync_error(metric_name, response.status_code)
-            else:
-                self._telemetry_runtime_producer.record_suceessful_sync(metric_name, round(1000 * elapsed))
             return response
         except Exception as exc:  # pylint: disable=broad-except
             raise HttpClientException('requests library is throwing exceptions') from exc

splitio/api/commons.py

@@ -32,6 +32,27 @@ def headers_from_metadata(sdk_metadata, client_key=None):
 
     return metadata
 
+def record_telemetry(status_code, elapsed, metric_name, telemetry_runtime_producer):
+    """
+    Record Telemetry info
+
+    :param status_code: http request status code
+    :type status_code: int
+
+    :param elapsed: response time elapsed.
+    :type status_code: int
+
+    :param metric_name: metric name for telemetry
+    :type metric_name: str
+
+    :param telemetry_runtime_producer: telemetry recording instance
+    :type telemetry_runtime_producer: splitio.engine.telemetry.TelemetryRuntimeProducer
+    """
+    telemetry_runtime_producer.record_sync_latency(metric_name, elapsed)
+    if 200 <= status_code < 300:
+        telemetry_runtime_producer.record_suceessful_sync(metric_name, elapsed)
+    else:
+        telemetry_runtime_producer.record_sync_error(metric_name, status_code)
 
 class FetchOptions(object):
     """Fetch Options object."""

splitio/api/events.py

@@ -1,9 +1,11 @@
 """Events API module."""
 import logging
+import time
 
 from splitio.api import APIException
 from splitio.api.client import HttpClientException
-from splitio.api.commons import headers_from_metadata
+from splitio.api.commons import headers_from_metadata, record_telemetry
+from splitio.models.telemetry import EVENT
 
 
 _LOGGER = logging.getLogger(__name__)
@@ -12,7 +14,7 @@
 class EventsAPI(object):  # pylint: disable=too-few-public-methods
     """Class that uses an httpClient to communicate with the events API."""
 
-    def __init__(self, http_client, apikey, sdk_metadata):
+    def __init__(self, http_client, apikey, sdk_metadata, telemetry_runtime_producer):
         """
         Class constructor.
 
@@ -26,6 +28,7 @@ def __init__(self, http_client, apikey, sdk_metadata):
         self._client = http_client
         self._apikey = apikey
         self._metadata = headers_from_metadata(sdk_metadata)
+        self._telemetry_runtime_producer = telemetry_runtime_producer
 
     @staticmethod
     def _build_bulk(events):
@@ -61,15 +64,16 @@ def flush_events(self, events):
         :rtype: bool
         """
         bulk = self._build_bulk(events)
+        start = int(round(time.time() * 1000))
         try:
             response = self._client.post(
                 'events',
                 '/events/bulk',
                 self._apikey,
                 body=bulk,
                 extra_headers=self._metadata,
-                metric_name='event'
             )
+            record_telemetry(response.status_code, int(round(time.time() * 1000)) - start, 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

@@ -2,11 +2,13 @@
 
 import logging
 from itertools import groupby
+import time
 
 from splitio.api import APIException
 from splitio.api.client import HttpClientException
-from splitio.api.commons import headers_from_metadata
-from splitio.engine.impressions.impressions import ImpressionsMode
+from splitio.api.commons import headers_from_metadata, record_telemetry
+from splitio.engine.impressions import ImpressionsMode
+from splitio.models.telemetry import IMPRESSION, IMPRESSION_COUNT
 
 
 _LOGGER = logging.getLogger(__name__)
@@ -15,7 +17,7 @@
 class ImpressionsAPI(object):  # pylint: disable=too-few-public-methods
     """Class that uses an httpClient to communicate with the impressions API."""
 
-    def __init__(self, client, apikey, sdk_metadata, mode=ImpressionsMode.OPTIMIZED):
+    def __init__(self, client, apikey, sdk_metadata, telemetry_runtime_producer, mode=ImpressionsMode.OPTIMIZED):
         """
         Class constructor.
 
@@ -28,6 +30,7 @@ def __init__(self, client, apikey, sdk_metadata, mode=ImpressionsMode.OPTIMIZED)
         self._apikey = apikey
         self._metadata = headers_from_metadata(sdk_metadata)
         self._metadata['SplitSDKImpressionsMode'] = mode.name
+        self._telemetry_runtime_producer = telemetry_runtime_producer
 
     @staticmethod
     def _build_bulk(impressions):
@@ -91,15 +94,16 @@ def flush_impressions(self, impressions):
         :type impressions: list
         """
         bulk = self._build_bulk(impressions)
+        start = int(round(time.time() * 1000))
         try:
             response = self._client.post(
                 'events',
                 '/testImpressions/bulk',
                 self._apikey,
                 body=bulk,
                 extra_headers=self._metadata,
-                metric_name='impression'
             )
+            record_telemetry(response.status_code, int(round(time.time() * 1000)) - start, IMPRESSION, self._telemetry_runtime_producer)
             if not 200 <= response.status_code < 300:
                 raise APIException(response.body, response.status_code)
         except HttpClientException as exc:
@@ -117,15 +121,16 @@ def flush_counters(self, counters):
         :type impressions: list
         """
         bulk = self._build_counters(counters)
+        start = int(round(time.time() * 1000))
         try:
             response = self._client.post(
                 'events',
                 '/testImpressions/count',
                 self._apikey,
                 body=bulk,
                 extra_headers=self._metadata,
-                metric_name='im'
             )
+            record_telemetry(response.status_code, int(round(time.time() * 1000)) - start, 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

@@ -2,10 +2,12 @@
 
 import json
 import logging
+import time
 
 from splitio.api import APIException
-from splitio.api.commons import headers_from_metadata, build_fetch
+from splitio.api.commons import headers_from_metadata, build_fetch, record_telemetry
 from splitio.api.client import HttpClientException
+from splitio.models.telemetry import SEGMENT
 
 
 _LOGGER = logging.getLogger(__name__)
@@ -14,7 +16,7 @@
 class SegmentsAPI(object):  # pylint: disable=too-few-public-methods
     """Class that uses an httpClient to communicate with the segments API."""
 
-    def __init__(self, http_client, apikey, sdk_metadata):
+    def __init__(self, http_client, apikey, sdk_metadata, telemetry_runtime_producer):
         """
         Class constructor.
 
@@ -29,6 +31,7 @@ def __init__(self, http_client, apikey, sdk_metadata):
         self._client = http_client
         self._apikey = apikey
         self._metadata = headers_from_metadata(sdk_metadata)
+        self._telemetry_runtime_producer = telemetry_runtime_producer
 
     def fetch_segment(self, segment_name, change_number, fetch_options):
         """
@@ -46,6 +49,7 @@ def fetch_segment(self, segment_name, change_number, fetch_options):
         :return: Json representation of a segmentChange response.
         :rtype: dict
         """
+        start = int(round(time.time() * 1000))
         try:
             query, extra_headers = build_fetch(change_number, fetch_options, self._metadata)
             response = self._client.get(
@@ -54,8 +58,8 @@ def fetch_segment(self, segment_name, change_number, fetch_options):
                 self._apikey,
                 extra_headers=extra_headers,
                 query=query,
-                metric_name='segment'
             )
+            record_telemetry(response.status_code, int(round(time.time() * 1000)) - start, SEGMENT, self._telemetry_runtime_producer)
             if 200 <= response.status_code < 300:
                 return json.loads(response.body)
             else:

splitio/api/splits.py

@@ -2,19 +2,20 @@
 
 import logging
 import json
+import time
 
 from splitio.api import APIException
-from splitio.api.commons import headers_from_metadata, build_fetch
+from splitio.api.commons import headers_from_metadata, build_fetch, record_telemetry
 from splitio.api.client import HttpClientException
-
+from splitio.models.telemetry import SPLIT
 
 _LOGGER = logging.getLogger(__name__)
 
 
 class SplitsAPI(object):  # pylint: disable=too-few-public-methods
     """Class that uses an httpClient to communicate with the splits API."""
 
-    def __init__(self, client, apikey, sdk_metadata):
+    def __init__(self, client, apikey, sdk_metadata, telemetry_runtime_producer):
         """
         Class constructor.
 
@@ -28,6 +29,7 @@ def __init__(self, client, apikey, sdk_metadata):
         self._client = client
         self._apikey = apikey
         self._metadata = headers_from_metadata(sdk_metadata)
+        self._telemetry_runtime_producer = telemetry_runtime_producer
 
     def fetch_splits(self, change_number, fetch_options):
         """
@@ -42,6 +44,7 @@ def fetch_splits(self, change_number, fetch_options):
         :return: Json representation of a splitChanges response.
         :rtype: dict
         """
+        start = int(round(time.time() * 1000))
         try:
             query, extra_headers = build_fetch(change_number, fetch_options, self._metadata)
             response = self._client.get(
@@ -50,8 +53,8 @@ def fetch_splits(self, change_number, fetch_options):
                 self._apikey,
                 extra_headers=extra_headers,
                 query=query,
-                metric_name='split'
             )
+            record_telemetry(response.status_code, int(round(time.time() * 1000)) - start, SPLIT, self._telemetry_runtime_producer)
             if 200 <= response.status_code < 300:
                 return json.loads(response.body)
             else: