Created strategry class from factory instead of impression manager

Author: chillaq

splitio/client/factory.py

@@ -12,6 +12,9 @@
 from splitio.client import util
 from splitio.client.listener import ImpressionListenerWrapper
 from splitio.engine.impressions import Manager as ImpressionsManager
+from splitio.engine.strategies.strategy_debug_mode import StrategyDebugMode
+from splitio.engine.strategies.strategy_optimized_mode import StrategyOptimizedMode
+
 
 # Storage
 from splitio.storage.inmemmory import InMemorySplitStorage, InMemorySegmentStorage, \
@@ -314,10 +317,13 @@ def _build_in_memory_factory(api_key, cfg, sdk_url=None, events_url=None,  # pyl
         'events': InMemoryEventStorage(cfg['eventsQueueSize']),
     }
 
+    imp_strategy = StrategyOptimizedMode(True) if cfg['ImpressionsMode'] == 'OPTIMIZED' else StrategyDebugMode(True)
+
     imp_manager = ImpressionsManager(
         cfg['impressionsMode'],
         True,
-        _wrap_impression_listener(cfg['impressionListener'], sdk_metadata))
+        _wrap_impression_listener(cfg['impressionListener'], sdk_metadata),
+        imp_strategy)
 
     synchronizers = SplitSynchronizers(
         SplitSynchronizer(apis['splits'], storages['splits']),

splitio/engine/impressions.py

@@ -6,11 +6,6 @@
 from splitio.engine.strategies.strategy_optimized_mode import StrategyOptimizedMode
 from splitio.engine.strategies import Observer, Counter
 
-import logging
-_LOGGER = logging.getLogger(__name__)
-
-_IMPRESSION_OBSERVER_CACHE_SIZE = 500000
-
 class ImpressionsMode(Enum):
     """Impressions tracking mode."""
 
@@ -20,7 +15,7 @@ class ImpressionsMode(Enum):
 class Manager(object):  # pylint:disable=too-few-public-methods
     """Impression manager."""
 
-    def __init__(self, mode=ImpressionsMode.OPTIMIZED, standalone=True, listener=None):
+    def __init__(self, mode=ImpressionsMode.OPTIMIZED, standalone=True, listener=None, strategy=None):
         """
         Construct a manger to track and forward impressions to the queue.
 
@@ -33,20 +28,11 @@ def __init__(self, mode=ImpressionsMode.OPTIMIZED, standalone=True, listener=Non
         :param listener: Optional impressions listener that will capture all seen impressions.
         :type listener: splitio.client.listener.ImpressionListenerWrapper
         """
-        self._observer = Observer(_IMPRESSION_OBSERVER_CACHE_SIZE) if standalone else None
+
         self._counter = Counter() if standalone else None
-        self._strategy = self.get_strategy(mode, standalone)
+        self._strategy = strategy
         self._listener = listener
 
-    def get_strategy(self, mode, standalone):
-        """
-        Return a strategy object based on mode value.
-
-        :returns: A strategy object
-        :rtype: (BaseStrategy)
-        """
-        return StrategyOptimizedMode(self._counter, self._observer, standalone) if mode == ImpressionsMode.OPTIMIZED else StrategyDebugMode(self._observer, standalone)
-
     def process_impressions(self, impressions):
         """
         Process impressions.
@@ -56,7 +42,7 @@ def process_impressions(self, impressions):
         :param impressions: List of impression objects with attributes
         :type impressions: list[tuple[splitio.models.impression.Impression, dict]]
         """
-        for_log, for_listener = self._strategy.process_impressions(impressions)
+        for_log, for_listener = self._strategy.process_impressions(impressions, self._counter)
         self._send_impressions_to_listener(for_listener)
         return for_log
 

splitio/engine/strategies/strategy_debug_mode.py

@@ -6,15 +6,14 @@
 class StrategyDebugMode(BaseStrategy):
     """Debug mode strategy."""
 
-    def __init__(self, observer=None, standalone=True):
+    def __init__(self, standalone=True):
         """
         Construct a strategy instance for debug mode.
 
         """
-        self._standalone = standalone
-        self._observer =  observer
+        self._observer = Observer(_IMPRESSION_OBSERVER_CACHE_SIZE) if standalone else None
 
-    def process_impressions(self, impressions):
+    def process_impressions(self, impressions, counter=None):
         """
         Process impressions.
 
@@ -26,5 +25,5 @@ def process_impressions(self, impressions):
         :returns: Observed list of impressions
         :rtype: list[tuple[splitio.models.impression.Impression, dict]]
         """
-        for_listener = [(self._observer.test_and_set(imp), attrs) for imp, attrs in impressions] if self._observer is not None else impressions
-        return truncate_impressions_time(for_listener, None), for_listener
+        imps = [(self._observer.test_and_set(imp), attrs) for imp, attrs in impressions] if self._observer is not None else impressions
+        return [i for i, _ in imps], imps

splitio/engine/strategies/strategy_optimized_mode.py

@@ -1,20 +1,20 @@
 from splitio.engine.strategies.base_strategy import BaseStrategy
-from splitio.engine.strategies import Observer, Counter, truncate_impressions_time
+from splitio.engine.strategies import Observer, Counter, truncate_time
 from splitio import util
 
+_IMPRESSION_OBSERVER_CACHE_SIZE = 500000
+
 class StrategyOptimizedMode(BaseStrategy):
     """Optimized mode strategy."""
 
-    def __init__(self, counter=None, observer=None, standalone=True):
+    def __init__(self, standalone=True):
         """
         Construct a strategy instance for optimized mode.
 
         """
-        self._standalone = standalone
-        self._counter = counter
-        self._observer =  observer
+        self._observer = Observer(_IMPRESSION_OBSERVER_CACHE_SIZE) if standalone else None
 
-    def process_impressions(self, impressions):
+    def process_impressions(self, impressions, counter):
         """
         Process impressions.
 
@@ -26,7 +26,7 @@ def process_impressions(self, impressions):
         :returns: Observed list of impressions
         :rtype: list[tuple[splitio.models.impression.Impression, dict]]
         """
-        forListener = [(self._observer.test_and_set(imp), attrs) for imp, attrs in impressions] if self._observer else impressions
-        if self._counter is not None:
-            self._counter.track([imp for imp, _ in forListener])
-        return truncate_impressions_time(forListener, self._counter), forListener
+        imps = [(self._observer.test_and_set(imp), attrs) for imp, attrs in impressions] if self._observer else impressions
+        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