cleanup

Author: chillaq

splitio/api/telemetry.py

@@ -6,8 +6,6 @@
 from splitio.api.client import HttpClientException
 from splitio.api.commons import headers_from_metadata
 
-_LOGGER = logging.getLogger(__name__)
-
 class TelemetryAPI(object):  # pylint: disable=too-few-public-methods
     """Class that uses an httpClient to communicate with the Telemetry API."""
 
@@ -31,7 +29,6 @@ def record_unique_keys(self, uniques):
         :param uniques: Unique Keys
         :type json
         """
-        _LOGGER.debug(uniques)
         try:
             response = self._client.post(
                 'telemetry',

splitio/client/factory.py

@@ -327,8 +327,17 @@ def _build_in_memory_factory(api_key, cfg, sdk_url=None, events_url=None,  # pyl
     }
     imp_counter = ImpressionsCounter() if cfg['impressionsMode'] != ImpressionsMode.DEBUG else None
 
+    unique_keys_synchronizer = None
+    clear_filter_sync = None
+    unique_keys_task = None
+    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)
+        unique_keys_task = UniqueKeysSyncTask(unique_keys_synchronizer.SendAll)
+        clear_filter_task = ClearFilterSyncTask(clear_filter_sync.clearAll)
+        imp_strategy._unique_keys_tracker.set_queue_full_hook(unique_keys_task.flush)
     elif cfg['impressionsMode'] == ImpressionsMode.DEBUG:
         imp_strategy = StrategyDebugMode()
     else:
@@ -344,49 +353,29 @@ def _build_in_memory_factory(api_key, cfg, sdk_url=None, events_url=None,  # pyl
         ImpressionSynchronizer(apis['impressions'], storages['impressions'],
                                cfg['impressionsBulkSize']),
         EventSynchronizer(apis['events'], storages['events'], cfg['eventsBulkSize']),
-        ImpressionsCountSynchronizer(apis['impressions'], imp_manager),
+        ImpressionsCountSynchronizer(apis['impressions'], imp_counter),
+        unique_keys_synchronizer,
+        clear_filter_sync
     )
 
-    if cfg['impressionsMode'] == ImpressionsMode.NONE:
-        synchronizers.set_none_sync(
-            UniqueKeysSynchronizer(InMemorySenderAdapter(apis['telemetry']), imp_strategy._unique_keys_tracker),
-            ClearFilterSynchronizer(imp_strategy._unique_keys_tracker)
-        )
-        tasks = SplitTasks(
-            SplitSynchronizationTask(
-                synchronizers.split_sync.synchronize_splits,
-                cfg['featuresRefreshRate'],
-            ),
-            SegmentSynchronizationTask(
-                synchronizers.segment_sync.synchronize_segments,
-                cfg['segmentsRefreshRate'],
-            ),
-            ImpressionsSyncTask(
-                synchronizers.impressions_sync.synchronize_impressions,
-                cfg['impressionsRefreshRate'],
-            ),
-            EventsSyncTask(synchronizers.events_sync.synchronize_events, cfg['eventsPushRate']),
-            ImpressionsCountSyncTask(synchronizers.impressions_count_sync.synchronize_counters),
-            UniqueKeysSyncTask(synchronizers.unique_keys_sync.SendAll),
-            ClearFilterSyncTask(synchronizers.clear_filter_sync.clearAll)
-        )
-    else:
-        tasks = SplitTasks(
-            SplitSynchronizationTask(
-                synchronizers.split_sync.synchronize_splits,
-                cfg['featuresRefreshRate'],
-            ),
-            SegmentSynchronizationTask(
-                synchronizers.segment_sync.synchronize_segments,
-                cfg['segmentsRefreshRate'],
-            ),
-            ImpressionsSyncTask(
-                synchronizers.impressions_sync.synchronize_impressions,
-                cfg['impressionsRefreshRate'],
-            ),
-            EventsSyncTask(synchronizers.events_sync.synchronize_events, cfg['eventsPushRate']),
-            ImpressionsCountSyncTask(synchronizers.impressions_count_sync.synchronize_counters),
-        )
+    tasks = SplitTasks(
+        SplitSynchronizationTask(
+            synchronizers.split_sync.synchronize_splits,
+            cfg['featuresRefreshRate'],
+        ),
+        SegmentSynchronizationTask(
+            synchronizers.segment_sync.synchronize_segments,
+            cfg['segmentsRefreshRate'],
+        ),
+        ImpressionsSyncTask(
+            synchronizers.impressions_sync.synchronize_impressions,
+            cfg['impressionsRefreshRate'],
+        ),
+        EventsSyncTask(synchronizers.events_sync.synchronize_events, cfg['eventsPushRate']),
+        ImpressionsCountSyncTask(synchronizers.impressions_count_sync.synchronize_counters),
+        unique_keys_task,
+        clear_filter_task
+    )
 
     synchronizer = Synchronizer(synchronizers, tasks)
 
@@ -398,8 +387,6 @@ def _build_in_memory_factory(api_key, cfg, sdk_url=None, events_url=None,  # pyl
 
     storages['events'].set_queue_full_hook(tasks.events_task.flush)
     storages['impressions'].set_queue_full_hook(tasks.impressions_task.flush)
-    if cfg['impressionsMode'] == ImpressionsMode.NONE:
-        imp_strategy._unique_keys_tracker.set_queue_full_hook(tasks._unique_keys_task.flush)
 
     recorder = StandardRecorder(
         imp_manager,

splitio/engine/strategies/strategy_none_mode.py

@@ -9,7 +9,7 @@
 class StrategyNoneMode(BaseStrategy):
     """Debug mode strategy."""
 
-    def __init__(self, counter=None):
+    def __init__(self, counter):
         """
         Construct a strategy instance for none mode.
 

splitio/sync/impression.py

@@ -68,7 +68,7 @@ def synchronize_impressions(self):
 
 
 class ImpressionsCountSynchronizer(object):
-    def __init__(self, impressions_api, impressions_manager):
+    def __init__(self, impressions_api, imp_counter):
         """
         Class constructor.
 
@@ -79,15 +79,15 @@ def __init__(self, impressions_api, impressions_manager):
 
         """
         self._impressions_api = impressions_api
-        self._impressions_manager = impressions_manager
+        self._impressions_counter = imp_counter
 
     def synchronize_counters(self):
         """Send impressions from both the failed and new queues."""
 
-        if not isinstance(self._impressions_manager._strategy._counter, Counter):
+        if not isinstance(self._impressions_counter, Counter):
             return
 
-        to_send = self._impressions_manager._strategy._counter.pop_all()
+        to_send = self._impressions_counter.pop_all()
         if not to_send:
             return
 

splitio/sync/synchronizer.py

@@ -14,7 +14,7 @@ class SplitSynchronizers(object):
     """SplitSynchronizers."""
 
     def __init__(self, split_sync, segment_sync, impressions_sync, events_sync,  # pylint:disable=too-many-arguments
-                 impressions_count_sync):
+                 impressions_count_sync, unique_keys_sync = None, clear_filter_sync = None):
         """
         Class constructor.
 
@@ -34,8 +34,6 @@ def __init__(self, split_sync, segment_sync, impressions_sync, events_sync,  # p
         self._impressions_sync = impressions_sync
         self._events_sync = events_sync
         self._impressions_count_sync = impressions_count_sync
-
-    def set_none_sync(self, unique_keys_sync, clear_filter_sync):
         self._unique_keys_sync = unique_keys_sync
         self._clear_filter_sync = clear_filter_sync
 
@@ -329,6 +327,7 @@ def start_periodic_data_recording(self):
         self._split_tasks.impressions_count_task.start()
         if self._split_tasks.unique_keys_task is not None:
             self._split_tasks.unique_keys_task.start()
+        if self._split_tasks.clear_filter_task is not None:
             self._split_tasks.clear_filter_task.start()
 
     def stop_periodic_data_recording(self, blocking):
@@ -346,6 +345,7 @@ def stop_periodic_data_recording(self, blocking):
                     self._split_tasks.impressions_count_task]
             if self._split_tasks.unique_keys_task is not None:
                 tasks.append(self._split_tasks.unique_keys_task)
+            if self._split_tasks.clear_filter_task is not None:
                 tasks.append(self._split_tasks.clear_filter_task)
 
             for task in tasks:
@@ -360,6 +360,7 @@ def stop_periodic_data_recording(self, blocking):
             self._split_tasks.impressions_count_task.stop()
             if self._split_tasks.unique_keys_task is not None:
                 self._split_tasks.unique_keys_task.stop()
+            if self._split_tasks.clear_filter_task is not None:
                 self._split_tasks.clear_filter_task.stop()
 
     def kill_split(self, split_name, default_treatment, change_number):
@@ -376,8 +377,6 @@ def kill_split(self, split_name, default_treatment, change_number):
         self._split_synchronizers.split_sync.kill_split(split_name, default_treatment,
                                                         change_number)
 
-
-
 class LocalhostSynchronizer(BaseSynchronizer):
     """LocalhostSynchronizer."""
 

splitio/sync/unique_keys.py

@@ -9,14 +9,13 @@
 class UniqueKeysSynchronizer(object):
     """Unique Keys Synchronizer class."""
 
-    def __init__(self, impressions_sender_adapter = None, uniqe_keys_tracker = None):
+    def __init__(self, impressions_sender_adapter, uniqe_keys_tracker):
         """
         Initialize Unique keys synchronizer instance
 
         :param uniqe_keys_tracker: instance of uniqe keys tracker
         :type uniqe_keys_tracker: splitio.engine.uniqur_key_tracker.UniqueKeysTracker
         """
-        _LOGGER.debug("UniqueKeysSynchronizer")
         self._uniqe_keys_tracker = uniqe_keys_tracker
         self._max_bulk_size = _UNIQUE_KEYS_MAX_BULK_SIZE
         self._impressions_sender_adapter = impressions_sender_adapter
@@ -73,7 +72,7 @@ def _chunks(self, keys_list):
 class ClearFilterSynchronizer(object):
     """Clear filter class."""
 
-    def __init__(self, unique_keys_tracker = None):
+    def __init__(self, unique_keys_tracker):
         """
         Initialize Unique keys synchronizer instance
 

tests/sync/test_impressions_count_synchronizer.py

@@ -29,7 +29,7 @@ def test_synchronize_impressions_counts(self, mocker):
         counter.pop_all.return_value = counters
         api = mocker.Mock(spec=ImpressionsAPI)
         api.flush_counters.return_value = HttpResponse(200, '')
-        impression_count_synchronizer = ImpressionsCountSynchronizer(api, ImpressionsManager(mocker.Mock(), StrategyOptimizedMode(counter)))
+        impression_count_synchronizer = ImpressionsCountSynchronizer(api, counter)
         impression_count_synchronizer.synchronize_counters()
 
         assert counter.pop_all.mock_calls[0] == mocker.call()

tests/tasks/test_impressions_sync.py

@@ -64,7 +64,7 @@ def test_normal_operation(self, mocker):
         api = mocker.Mock(spec=ImpressionsAPI)
         api.flush_counters.return_value = HttpResponse(200, '')
         impressions_sync.ImpressionsCountSyncTask._PERIOD = 1
-        impression_synchronizer = ImpressionsCountSynchronizer(api, ImpressionsManager(mocker.Mock(), StrategyOptimizedMode(counter)))
+        impression_synchronizer = ImpressionsCountSynchronizer(api, counter)
         task = impressions_sync.ImpressionsCountSyncTask(
             impression_synchronizer.synchronize_counters
         )

tests/tasks/test_unique_keys_sync.py

@@ -22,7 +22,7 @@ def test_normal_operation(self, mocker):
         unique_keys_tracker.track("key1", "split1")
         unique_keys_tracker.track("key2", "split1")
 
-        unique_keys_sync = UniqueKeysSynchronizer(unique_keys_tracker)
+        unique_keys_sync = UniqueKeysSynchronizer(mocker.Mock(), unique_keys_tracker)
         task = UniqueKeysSyncTask(unique_keys_sync.SendAll, 1)
         task.start()
         time.sleep(2)