cleanup and fix redis unique keys push

Author: chillaq

splitio/client/util.py

@@ -6,12 +6,28 @@
 
 from splitio.models.telemetry import MethodExceptionsAndLatencies
 
+_MAP_METHOD_TO_ENUM = {'treatment': MethodExceptionsAndLatencies.TREATMENT,
+                       'treatments': MethodExceptionsAndLatencies.TREATMENTS,
+                        'treatment_with_config': MethodExceptionsAndLatencies.TREATMENT_WITH_CONFIG,
+                        'treatments_with_config': MethodExceptionsAndLatencies.TREATMENTS_WITH_CONFIG,
+                        'track': MethodExceptionsAndLatencies.TRACK
+                       }
+
 SdkMetadata = namedtuple(
     'SdkMetadata',
     ['sdk_version', 'instance_name', 'instance_ip']
 )
 
 def _get_hostname_and_ip(config):
+    """
+    Get current hostname and IP address if config parameters are not set.
+
+    :param config: User supplied config augmented with defaults.
+    :type config: dict
+
+    :return: IP address and Hostname
+    :rtype: Tuple (str, str)
+    """
     if config.get('IPAddressesEnabled') is False:
         return 'NA', 'NA'
     ip_from_config = config.get('machineIp')
@@ -35,13 +51,10 @@ def get_metadata(config):
     return SdkMetadata(version, hostname, ip_address)
 
 def get_method_constant(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
-    elif method == 'track':
-        return MethodExceptionsAndLatencies.TRACK
+    """
+    Get method name mapped to the Method Enum object
+
+    :return: method name
+    :rtype: str
+    """
+    return _MAP_METHOD_TO_ENUM[method]

splitio/engine/impressions/__init__.py

@@ -14,19 +14,21 @@ def set_classes(storage_mode, impressions_mode, api_adapter):
     clear_filter_task = None
     impressions_count_sync = None
     impressions_count_task = None
+    sender_adapter = None
     if storage_mode == 'REDIS':
-        redis_sender_adapter = RedisSenderAdapter(api_adapter)
-        api_telemetry_adapter = redis_sender_adapter
-        api_impressions_adapter = redis_sender_adapter
+        sender_adapter = RedisSenderAdapter(api_adapter)
+        api_telemetry_adapter = sender_adapter
+        api_impressions_adapter = sender_adapter
     else:
         api_telemetry_adapter = api_adapter['telemetry']
         api_impressions_adapter = api_adapter['impressions']
+        sender_adapter = InMemorySenderAdapter(api_telemetry_adapter)
 
     if impressions_mode == ImpressionsMode.NONE:
         imp_counter = ImpressionsCounter()
         imp_strategy = StrategyNoneMode(imp_counter)
         clear_filter_sync = ClearFilterSynchronizer(imp_strategy.get_unique_keys_tracker())
-        unique_keys_synchronizer = UniqueKeysSynchronizer(InMemorySenderAdapter(api_telemetry_adapter), imp_strategy.get_unique_keys_tracker())
+        unique_keys_synchronizer = UniqueKeysSynchronizer(sender_adapter, imp_strategy.get_unique_keys_tracker())
         unique_keys_task = UniqueKeysSyncTask(unique_keys_synchronizer.send_all)
         clear_filter_task = ClearFilterSyncTask(clear_filter_sync.clear_all)
         imp_strategy.get_unique_keys_tracker().set_queue_full_hook(unique_keys_task.flush)

splitio/engine/telemetry.py

@@ -172,7 +172,12 @@ def pop_latencies(self):
         return self._telemetry_storage.pop_latencies()
 
     def pop_formatted_stats(self):
-        """Get formatted and reset stats."""
+        """
+        Get formatted and reset stats.
+
+        :returns: formatted stats
+        :rtype: Dict
+        """
         exceptions = self.pop_exceptions()['methodExceptions']
         latencies = self.pop_latencies()['methodLatencies']
         return {
@@ -238,7 +243,12 @@ def get_session_length(self):
         return self._telemetry_storage.get_session_length()
 
     def pop_formatted_stats(self):
-        """Get formatted and reset stats."""
+        """
+        Get formatted and reset stats.
+
+        :returns: formatted stats
+        :rtype: Dict
+        """
         last_synchronization = self.get_last_synchronization()
         http_errors = self.pop_http_errors()['httpErrors']
         http_latencies = self.pop_http_latencies()['httpLatencies']

splitio/storage/adapters/redis.py

@@ -1,6 +1,5 @@
 """Redis client wrapper with prefix support."""
 from builtins import str
-import logging
 
 from splitio.version import __version__
 from splitio.util.host_info import get_ip, get_hostname
@@ -18,10 +17,7 @@ def missing_redis_dependencies(*_, **__):
         )
     StrictRedis = Sentinel = missing_redis_dependencies
 
-_LOGGER = logging.getLogger(__name__)
 TELEMETRY_CONFIG_KEY = 'SPLITIO.telemetry.init'
-TELEMETRY_EXCEPTIONS_KEY = 'SPLITIO.telemetry.exceptions'
-TELEMETRY_LATENCIES_KEY = 'SPLITIO.telemetry.latencies'
 
 class RedisAdapterException(Exception):
     """Exception to be thrown when a redis command fails with an exception."""
@@ -344,11 +340,11 @@ def rpush(self, key, *values):
     def incr(self, name, amount=1):
         """Mimic original redis function but using user custom prefix."""
         self._pipe.incr(self._prefix_helper.add_prefix(name), amount)
-        
+
     def hincrby(self, name, key, amount=1):
         """Mimic original redis function but using user custom prefix."""
         self._pipe.hincrby(self._prefix_helper.add_prefix(name), key, amount)
-        
+
     def execute(self):
         """Mimic original redis function but using user custom prefix."""
         try:

splitio/sync/telemetry.py

@@ -1,6 +1,4 @@
-import json
-import logging
-_LOGGER = logging.getLogger(__name__)
+"""Telemetry Sync Class."""
 
 from splitio.api.telemetry import TelemetryAPI
 from splitio.engine.telemetry import TelemetryStorageConsumer
@@ -41,7 +39,12 @@ def synchronize_stats(self):
         self._telemetry_api.record_stats(self._build_stats())
 
     def _build_stats(self):
-        """Format stats to JSON."""
+        """
+        Format stats to Dict.
+
+        :returns: formatted stats
+        :rtype: Dict
+        """
         merged_dict = {
             'spC': self._split_storage.get_splits_count(),
             'seC': self._segment_storage.get_segments_count(),

splitio/util/host_info.py

@@ -2,6 +2,12 @@
 import socket
 
 def get_ip():
+    """
+    Fetching current host IP address
+
+    :returns: IP address
+    :rtype: str
+    """
     sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
     try:
         # doesn't even have to be reachable
@@ -15,6 +21,12 @@ def get_ip():
 
 
 def get_hostname():
+    """
+    Fetching current host name
+
+    :returns: host name
+    :rtype: str
+    """
     try:
         return socket.gethostname()
     except Exception: