Merge pull request #199 from splitio/feature/streaming

Feature/streaming

Author: mredolatti

splitio/api/auth.py

@@ -0,0 +1,56 @@
+"""Auth API module."""
+
+import logging
+import json
+
+from future.utils import raise_from
+
+from splitio.api import APIException, headers_from_metadata
+from splitio.api.client import HttpClientException
+from splitio.models.token import from_raw
+
+
+_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):
+        """
+        Class constructor.
+
+        :param client: HTTP Client responsble for issuing calls to the backend.
+        :type client: HttpClient
+        :param apikey: User apikey token.
+        :type apikey: string
+        :param sdk_metadata: SDK version & machine name & IP.
+        :type sdk_metadata: splitio.client.util.SdkMetadata
+        """
+        self._client = client
+        self._apikey = apikey
+        self._metadata = headers_from_metadata(sdk_metadata)
+
+    def authenticate(self):
+        """
+        Perform authentication.
+
+        :return: Json representation of an authentication.
+        :rtype: splitio.models.token.Token
+        """
+        try:
+            response = self._client.get(
+                'auth',
+                '/auth',
+                self._apikey,
+                extra_headers=self._metadata
+            )
+            if 200 <= response.status_code < 300:
+                payload = json.loads(response.body)
+                return from_raw(payload)
+            else:
+                raise APIException(response.body, response.status_code)
+        except HttpClientException as exc:
+            _LOGGER.error('Exception raised while authenticating')
+            _LOGGER.debug('Exception information: ', exc_info=True)
+            raise_from(APIException('Could not perform authentication.'), exc)

splitio/api/client.py

@@ -27,8 +27,9 @@ class HttpClient(object):
 
     SDK_URL = 'https://sdk.split.io/api'
     EVENTS_URL = 'https://events.split.io/api'
+    AUTH_URL = 'https://auth.split.io/api'
 
-    def __init__(self, timeout=None, sdk_url=None, events_url=None):
+    def __init__(self, timeout=None, sdk_url=None, events_url=None, auth_url=None):
         """
         Class constructor.
 
@@ -38,11 +39,14 @@ def __init__(self, timeout=None, sdk_url=None, events_url=None):
         :type sdk_url: str
         :param events_url: Optional alternative events URL.
         :type events_url: str
+        :param auth_url: Optional alternative auth URL.
+        :type auth_url: str
         """
-        self._timeout = timeout / 1000  if timeout else None  # Convert ms to seconds.
+        self._timeout = timeout/1000 if timeout else None  # Convert ms to seconds.
         self._urls = {
             'sdk': sdk_url if sdk_url is not None else self.SDK_URL,
             'events': events_url if events_url is not None else self.EVENTS_URL,
+            'auth': auth_url if auth_url is not None else self.AUTH_URL,
         }
 
     def _build_url(self, server, path):
@@ -72,11 +76,11 @@ def _build_basic_headers(apikey):
             'Authorization': "Bearer %s" % apikey
         }
 
-    def get(self, server, path, apikey, query=None, extra_headers=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.
 
-        :param server: Whether the request is for SDK server or Events server.
+        :param server: Whether the request is for SDK server, Events server or Auth server.
         :typee server: str
         :param path: path to append to the host url.
         :type path: str
@@ -91,7 +95,6 @@ def get(self, server, path, apikey, query=None, extra_headers=None):  #pylint: d
         :rtype: HttpResponse
         """
         headers = self._build_basic_headers(apikey)
-
         if extra_headers is not None:
             headers.update(extra_headers)
 
@@ -103,10 +106,10 @@ def get(self, server, path, apikey, query=None, extra_headers=None):  #pylint: d
                 timeout=self._timeout
             )
             return HttpResponse(response.status_code, response.text)
-        except Exception as exc:  #pylint: disable=broad-except
+        except Exception as exc:  # pylint: disable=broad-except
             raise_from(HttpClientException('requests library is throwing exceptions'), exc)
 
-    def post(self, server, path, apikey, body, query=None, extra_headers=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.
 
@@ -140,5 +143,5 @@ def post(self, server, path, apikey, body, query=None, extra_headers=None):  #py
                 timeout=self._timeout
             )
             return HttpResponse(response.status_code, response.text)
-        except Exception as exc:  #pylint: disable=broad-except
+        except Exception as exc:  # pylint: disable=broad-except
             raise_from(HttpClientException('requests library is throwing exceptions'), exc)

splitio/api/events.py

@@ -7,6 +7,9 @@
 from splitio.api.client import HttpClientException
 
 
+_LOGGER = logging.getLogger(__name__)
+
+
 class EventsAPI(object):  # pylint: disable=too-few-public-methods
     """Class that uses an httpClient to communicate with the events API."""
 
@@ -21,7 +24,6 @@ def __init__(self, http_client, apikey, sdk_metadata):
         :param sdk_metadata: SDK version & machine name & IP.
         :type sdk_metadata: splitio.client.util.SdkMetadata
         """
-        self._logger = logging.getLogger(self.__class__.__name__)
         self._client = http_client
         self._apikey = apikey
         self._metadata = headers_from_metadata(sdk_metadata)
@@ -71,6 +73,6 @@ def flush_events(self, events):
             if not 200 <= response.status_code < 300:
                 raise APIException(response.body, response.status_code)
         except HttpClientException as exc:
-            self._logger.error('Http client is throwing exceptions')
-            self._logger.debug('Error: ', exc_info=True)
+            _LOGGER.error('Error posting events because an exception was raised by the HTTPClient')
+            _LOGGER.debug('Error: ', exc_info=True)
             raise_from(APIException('Events not flushed properly.'), exc)

splitio/api/impressions.py

@@ -10,6 +10,9 @@
 from splitio.engine.impressions import ImpressionsMode
 
 
+_LOGGER = logging.getLogger(__name__)
+
+
 class ImpressionsAPI(object):  # pylint: disable=too-few-public-methods
     """Class that uses an httpClient to communicate with the impressions API."""
 
@@ -22,7 +25,6 @@ def __init__(self, client, apikey, sdk_metadata, mode=ImpressionsMode.OPTIMIZED)
         :param apikey: User apikey token.
         :type apikey: string
         """
-        self._logger = logging.getLogger(self.__class__.__name__)
         self._client = client
         self._apikey = apikey
         self._metadata = headers_from_metadata(sdk_metadata)
@@ -101,8 +103,10 @@ def flush_impressions(self, impressions):
             if not 200 <= response.status_code < 300:
                 raise APIException(response.body, response.status_code)
         except HttpClientException as exc:
-            self._logger.error('Http client is throwing exceptions')
-            self._logger.debug('Error: ', exc_info=True)
+            _LOGGER.error(
+                'Error posting impressions because an exception was raised by the HTTPClient'
+            )
+            _LOGGER.debug('Error: ', exc_info=True)
             raise_from(APIException('Impressions not flushed properly.'), exc)
 
     def flush_counters(self, counters):
@@ -124,6 +128,9 @@ def flush_counters(self, counters):
             if not 200 <= response.status_code < 300:
                 raise APIException(response.body, response.status_code)
         except HttpClientException as exc:
-            self._logger.error('Http client is throwing exceptions')
-            self._logger.debug('Error: ', exc_info=True)
+            _LOGGER.error(
+                'Error posting impressions counters because an exception was raised by the '
+                'HTTPClient'
+            )
+            _LOGGER.debug('Error: ', exc_info=True)
             raise_from(APIException('Impressions not flushed properly.'), exc)

splitio/api/segments.py

@@ -9,7 +9,10 @@
 from splitio.api.client import HttpClientException
 
 
-class SegmentsAPI(object):  #pylint: disable=too-few-public-methods
+_LOGGER = logging.getLogger(__name__)
+
+
+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):
@@ -21,7 +24,6 @@ def __init__(self, http_client, apikey):
         :param apikey: User apikey token.
         :type apikey: string
         """
-        self._logger = logging.getLogger(self.__class__.__name__)
         self._client = http_client
         self._apikey = apikey
 
@@ -50,6 +52,9 @@ def fetch_segment(self, segment_name, change_number):
             else:
                 raise APIException(response.body, response.status_code)
         except HttpClientException as exc:
-            self._logger.error('Http client is throwing exceptions')
-            self._logger.debug('Error: ', exc_info=True)
+            _LOGGER.error(
+                'Error fetching %s because an exception was raised by the HTTPClient',
+                segment_name
+            )
+            _LOGGER.debug('Error: ', exc_info=True)
             raise_from(APIException('Segments not fetched properly.'), exc)

splitio/api/splits.py

@@ -9,7 +9,10 @@
 from splitio.api.client import HttpClientException
 
 
-class SplitsAPI(object):  #pylint: disable=too-few-public-methods
+_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):
@@ -21,7 +24,6 @@ def __init__(self, client, apikey):
         :param apikey: User apikey token.
         :type apikey: string
         """
-        self._logger = logging.getLogger(self.__class__.__name__)
         self._client = client
         self._apikey = apikey
 
@@ -47,6 +49,6 @@ def fetch_splits(self, change_number):
             else:
                 raise APIException(response.body, response.status_code)
         except HttpClientException as exc:
-            self._logger.error('Http client is throwing exceptions')
-            self._logger.debug('Error: ', exc_info=True)
+            _LOGGER.error('Error fetching splits because an exception was raised by the HTTPClient')
+            _LOGGER.debug('Error: ', exc_info=True)
             raise_from(APIException('Splits not fetched correctly.'), exc)

splitio/api/telemetry.py

@@ -8,6 +8,9 @@
 from splitio.api.client import HttpClientException
 
 
+_LOGGER = logging.getLogger(__name__)
+
+
 class TelemetryAPI(object):
     """Class to handle telemetry submission to the backend."""
 
@@ -22,10 +25,10 @@ def __init__(self, client, apikey, sdk_metadata):
         :param sdk_metadata: SDK Version, IP & Machine name
         :type sdk_metadata: splitio.client.util.SdkMetadata
         """
-        self._logger = logging.getLogger(self.__class__.__name__)
         self._client = client
         self._apikey = apikey
         self._metadata = headers_from_metadata(sdk_metadata)
+
     @staticmethod
     def _build_latencies(latencies):
         """
@@ -58,8 +61,10 @@ def flush_latencies(self, latencies):
             if not 200 <= response.status_code < 300:
                 raise APIException(response.body, response.status_code)
         except HttpClientException as exc:
-            self._logger.error('Http client is throwing exceptions')
-            self._logger.debug('Error: ', exc_info=True)
+            _LOGGER.error(
+                'Error posting latencies because an exception was raised by the HTTPClient'
+            )
+            _LOGGER.debug('Error: ', exc_info=True)
             raise_from(APIException('Latencies not flushed correctly.'), exc)
 
     @staticmethod
@@ -94,8 +99,10 @@ def flush_gauges(self, gauges):
             if not 200 <= response.status_code < 300:
                 raise APIException(response.body, response.status_code)
         except HttpClientException as exc:
-            self._logger.error('Http client is throwing exceptions')
-            self._logger.debug('Error: ', exc_info=True)
+            _LOGGER.error(
+                'Error posting gauges because an exception was raised by the HTTPClient'
+            )
+            _LOGGER.debug('Error: ', exc_info=True)
             raise_from(APIException('Gauges not flushed correctly.'), exc)
 
     @staticmethod
@@ -130,6 +137,8 @@ def flush_counters(self, counters):
             if not 200 <= response.status_code < 300:
                 raise APIException(response.body, response.status_code)
         except HttpClientException as exc:
-            self._logger.error('Http client is throwing exceptions')
-            self._logger.debug('Error: ', exc_info=True)
+            _LOGGER.error(
+                'Error posting counters because an exception was raised by the HTTPClient'
+            )
+            _LOGGER.debug('Error: ', exc_info=True)
             raise_from(APIException('Counters not flushed correctly.'), exc)