Refactor strategies, filters and adapters, and updated tests

Author: chillaq

splitio/client/factory.py

@@ -13,11 +13,9 @@
 from splitio.client.listener import ImpressionListenerWrapper
 from splitio.engine.impressions import Manager as ImpressionsManager
 from splitio.engine.impressions import ImpressionsMode
-from splitio.engine.strategies import Counter as ImpressionsCounter
-from splitio.engine.strategies.strategy_debug_mode import StrategyDebugMode
-from splitio.engine.strategies.strategy_optimized_mode import StrategyOptimizedMode
-from splitio.engine.strategies.strategy_none_mode import StrategyNoneMode
-from splitio.engine.sender_adapters.in_memory_sender_adapter import InMemorySenderAdapter
+from splitio.engine.manager import Counter as ImpressionsCounter
+from splitio.engine.strategies import StrategyNoneMode, StrategyDebugMode, StrategyOptimizedMode
+from splitio.engine.adapters import InMemorySenderAdapter
 
 # Storage
 from splitio.storage.inmemmory import InMemorySplitStorage, InMemorySegmentStorage, \
@@ -333,11 +331,11 @@ def _build_in_memory_factory(api_key, cfg, sdk_url=None, events_url=None,  # pyl
     clear_filter_task = None
     if cfg['impressionsMode'] == ImpressionsMode.NONE:
         imp_strategy = StrategyNoneMode(imp_counter)
-        clear_filter_sync = ClearFilterSynchronizer(imp_strategy._unique_keys_tracker)
-        unique_keys_synchronizer = UniqueKeysSynchronizer(InMemorySenderAdapter(apis['telemetry']), imp_strategy._unique_keys_tracker)
+        clear_filter_sync = ClearFilterSynchronizer(imp_strategy.get_unique_keys_tracker())
+        unique_keys_synchronizer = UniqueKeysSynchronizer(InMemorySenderAdapter(apis['telemetry']), 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._unique_keys_tracker.set_queue_full_hook(unique_keys_task.flush)
+        imp_strategy.get_unique_keys_tracker().set_queue_full_hook(unique_keys_task.flush)
     elif cfg['impressionsMode'] == ImpressionsMode.DEBUG:
         imp_strategy = StrategyDebugMode()
     else:

…der_adapters/in_memory_sender_adapter.py splitio/engine/adapters.pysplitio/engine/sender_adapters/in_memory_sender_adapter.py renamed to splitio/engine/adapters.py splitio/engine/sender_adapters/in_memory_sender_adapter.py renamed to splitio/engine/adapters.py

@@ -1,6 +1,17 @@
+import abc
 import json
 
-from splitio.engine.sender_adapters import ImpressionsSenderAdapter
+
+class ImpressionsSenderAdapter(object, metaclass=abc.ABCMeta):
+    """Impressions Sender Adapter interface."""
+
+    @abc.abstractmethod
+    def record_unique_keys(self, data):
+        """
+        No Return value
+
+        """
+        pass
 
 class InMemorySenderAdapter(ImpressionsSenderAdapter):
     """In Memory Impressions Sender Adapter class."""
@@ -33,9 +44,6 @@ def _uniques_formatter(self, uniques):
         :return: unique keys JSON
         :rtype: json
         """
-        if len(uniques) == 0:
-            return json.loads('{"keys": []}')
-
         return {
             'keys':  [{'f': feature, 'ks': list(keys)} for feature, keys in uniques.items()]
         }

splitio/engine/filters/bloom_filter.py splitio/engine/filters.pysplitio/engine/filters/bloom_filter.py renamed to splitio/engine/filters.py

@@ -1,6 +1,34 @@
-from splitio.engine.filters import BaseFilter
+import abc
+
 from bloom_filter2 import BloomFilter as BloomFilter2
 
+class BaseFilter(object, metaclass=abc.ABCMeta):
+    """Impressions Filter interface."""
+
+    @abc.abstractmethod
+    def add(self, data):
+        """
+        Return a boolean flag
+
+        """
+        pass
+
+    @abc.abstractmethod
+    def contains(self, data):
+        """
+        Return a boolean flag
+
+        """
+        pass
+
+    @abc.abstractmethod
+    def clear(self):
+        """
+        No return
+
+        """
+        pass
+
 class BloomFilter(BaseFilter):
     """Optimized mode strategy."""
 

splitio/engine/filters/__init__.py

@@ -0,0 +1,104 @@
+import abc
+
+from splitio.engine.manager import Observer, truncate_impressions_time, Counter, truncate_time
+from splitio.engine.unique_keys_tracker import UniqueKeysTracker
+from splitio import util
+
+_IMPRESSION_OBSERVER_CACHE_SIZE = 500000
+_UNIQUE_KEYS_CACHE_SIZE = 30000
+
+class BaseStrategy(object, metaclass=abc.ABCMeta):
+    """Strategy interface."""
+
+    @abc.abstractmethod
+    def process_impressions(self):
+        """
+        Return a list(impressions) object
+
+        """
+        pass
+
+class StrategyDebugMode(BaseStrategy):
+    """Debug mode strategy."""
+
+    def __init__(self):
+        """
+        Construct a strategy instance for debug mode.
+
+        """
+        self._observer = Observer(_IMPRESSION_OBSERVER_CACHE_SIZE)
+
+    def process_impressions(self, impressions):
+        """
+        Process impressions.
+
+        Impressions are analyzed to see if they've been seen before.
+
+        :param impressions: List of impression objects with attributes
+        :type impressions: list[tuple[splitio.models.impression.Impression, dict]]
+
+        :returns: Observed list of impressions
+        :rtype: list[tuple[splitio.models.impression.Impression, dict]]
+        """
+        imps = [(self._observer.test_and_set(imp), attrs) for imp, attrs in impressions]
+        return [i for i, _ in imps], imps
+
+class StrategyNoneMode(BaseStrategy):
+    """Debug mode strategy."""
+
+    def __init__(self, counter):
+        """
+        Construct a strategy instance for none mode.
+
+        """
+        self._counter = counter
+        self._unique_keys_tracker = UniqueKeysTracker(_UNIQUE_KEYS_CACHE_SIZE)
+
+    def process_impressions(self, impressions):
+        """
+        Process impressions.
+
+        Impressions are analyzed to see if they've been seen before and counted.
+        Unique keys tracking are updated.
+
+        :param impressions: List of impression objects with attributes
+        :type impressions: list[tuple[splitio.models.impression.Impression, dict]]
+
+        :returns: Empty list, no impressions to post
+        :rtype: list[]
+        """
+        self._counter.track([imp for imp, _ in impressions])
+        for i, _ in impressions:
+            self._unique_keys_tracker.track(i.matching_key, i.feature_name)
+        return [], impressions
+
+    def get_unique_keys_tracker(self):
+        return self._unique_keys_tracker
+
+class StrategyOptimizedMode(BaseStrategy):
+    """Optimized mode strategy."""
+
+    def __init__(self, counter):
+        """
+        Construct a strategy instance for optimized mode.
+
+        """
+        self._observer = Observer(_IMPRESSION_OBSERVER_CACHE_SIZE)
+        self._counter = counter
+
+    def process_impressions(self, impressions):
+        """
+        Process impressions.
+
+        Impressions are analyzed to see if they've been seen before and counted.
+
+        :param impressions: List of impression objects with attributes
+        :type impressions: list[tuple[splitio.models.impression.Impression, dict]]
+
+        :returns: Observed list of impressions
+        :rtype: list[tuple[splitio.models.impression.Impression, dict]]
+        """
+        imps = [(self._observer.test_and_set(imp), attrs) for imp, attrs in impressions]
+        self._counter.track([imp for imp, _ in imps])
+        this_hour = truncate_time(util.utctime_ms())
+        return [i for i, _ in imps if i.previous_time is None or i.previous_time < this_hour], imps