minor fixes and tests

Author: chillaq

splitio/api/telemetry.py

@@ -31,6 +31,7 @@ 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

@@ -347,32 +347,46 @@ def _build_in_memory_factory(api_key, cfg, sdk_url=None, events_url=None,  # pyl
         ImpressionsCountSynchronizer(apis['impressions'], imp_manager),
     )
 
-    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),
-    )
-
     if cfg['impressionsMode'] == ImpressionsMode.NONE:
-        synchronizers.set_none_syncs(
+        synchronizers.set_none_sync(
             UniqueKeysSynchronizer(InMemorySenderAdapter(apis['telemetry']), imp_strategy._unique_keys_tracker),
-            ClearFilterSynchronizer(imp_strategy._unique_keys_tracker),
+            ClearFilterSynchronizer(imp_strategy._unique_keys_tracker)
         )
-        tasks.set_none_tasks(
+        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),
+        )
 
     synchronizer = Synchronizer(synchronizers, tasks)
 

splitio/sync/synchronizer.py

@@ -35,15 +35,7 @@ def __init__(self, split_sync, segment_sync, impressions_sync, events_sync,  # p
         self._events_sync = events_sync
         self._impressions_count_sync = impressions_count_sync
 
-    def set_none_syncs(self, unique_keys_sync, clear_filter_sync):
-        """
-        Set the NONE mode synchonizer objects.
-
-        :param unique_keys_sync: sync for unique_keys
-        :type unique_keys_sync: splitio.sync.unique_keys.UniqueKeysSynchronizer
-        :param clear_filter_sync: sync for clear_filter
-        :type clear_filter_sync: splitio.sync.unique_keys.ClearFilterSynchronizer
-        """
+    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
 
@@ -86,7 +78,7 @@ class SplitTasks(object):
     """SplitTasks."""
 
     def __init__(self, split_task, segment_task, impressions_task, events_task,  # pylint:disable=too-many-arguments
-                 impressions_count_task):
+                 impressions_count_task, unique_keys_task = None, clear_filter_task = None):
         """
         Class constructor.
 
@@ -106,18 +98,6 @@ def __init__(self, split_task, segment_task, impressions_task, events_task,  # p
         self._impressions_task = impressions_task
         self._events_task = events_task
         self._impressions_count_task = impressions_count_task
-        self._unique_keys_task = None
-        self._clear_filter_task = None
-
-    def set_none_tasks(self, unique_keys_task, clear_filter_task):
-        """
-        Set the NONE mode synchonizer objects.
-
-        :param unique_keys_task: sync for unique_keys
-        :type unique_keys_task: splitio.tasks.unique_keys_sync.UniqueKeysSyncTask
-        :param clear_filter_task: sync for clear_filter
-        :type clear_filter_task: splitio.tasks.unique_keys_sync.ClearFilterSyncTask
-        """
         self._unique_keys_task = unique_keys_task
         self._clear_filter_task = clear_filter_task
 

splitio/sync/unique_keys.py

@@ -1,11 +1,8 @@
 from splitio.engine.filters.bloom_filter import BloomFilter
 from splitio.engine.sender_adapters.in_memory_sender_adapter import InMemorySenderAdapter
+import logging
 
 _UNIQUE_KEYS_MAX_BULK_SIZE = 5000
-import threading
-import logging
-from splitio.engine.filters.bloom_filter import BloomFilter
-from splitio.engine.sender_adapters.in_memory_sender_adapter import InMemorySenderAdapter
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -19,6 +16,7 @@ def __init__(self, impressions_sender_adapter = None, uniqe_keys_tracker = None)
         :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
@@ -37,17 +35,6 @@ def SendAll(self):
                 self._impressions_sender_adapter.record_unique_keys(bulk)
 
     def _split_cache_to_bulks(self, cache):
-        cache_size = self._uniqe_keys_tracker._get_dict_size()
-        if cache_size <= self._max_bulk_size:
-            self._uniqe_keys_tracker._impressions_sender_adapter.record_unique_keys(self._uniqe_keys_tracker._cache)
-        else:
-            for bulk in self._split_cache_to_bulks():
-                self._uniqe_keys_tracker._impressions_sender_adapter.record_unique_keys(bulk)
-
-        with self._lock:
-            self._uniqe_keys_tracker._cache = {}
-
-    def _split_cache_to_bulks(self):
         """
         Split the current unique keys dictionary into seperate dictionaries,
         each with the size of max_bulk_size. Overflow the last feature set() to new unique keys dictionary.
@@ -80,24 +67,24 @@ def _chunks(self, keys_list):
         """
         Split array into chunks
         """
-        for i in range(0, len(keys_list), 5):
-            yield keys_list[i:i + 5]
+        for i in range(0, len(keys_list), self._max_bulk_size):
+            yield keys_list[i:i + self._max_bulk_size]
 
 class ClearFilterSynchronizer(object):
     """Clear filter class."""
 
-    def __init__(self, uniqe_keys_tracker = None):
+    def __init__(self, unique_keys_tracker = None):
         """
         Initialize Unique keys synchronizer instance
 
         :param uniqe_keys_tracker: instance of uniqe keys tracker
         :type uniqe_keys_tracker: splitio.engine.uniqur_key_tracker.UniqueKeysTracker
         """
-        self._uniqe_keys_tracker = uniqe_keys_tracker
+        self._unique_keys_tracker = unique_keys_tracker
 
     def clearAll(self):
         """
         Clear the bloom filter cache
 
         """
-        self._uniqe_keys_tracker.filter_pop_all()
+        self._unique_keys_tracker.filter_pop_all()

splitio/tasks/unique_keys_sync.py

@@ -6,12 +6,14 @@
 
 
 _LOGGER = logging.getLogger(__name__)
-_PERIOD = 15 * 60  # 15 minutes
+_UNIQUE_KEYS_SYNC_PERIOD = 15 * 60  # 15 minutes
+_CLEAR_FILTER_SYNC_PERIOD = 60 * 60 * 24  # 24 hours
+
 
 class UniqueKeysSyncTask(BaseSynchronizationTask):
     """Unique Keys synchronization task uses an asynctask.AsyncTask to send MTKs."""
 
-    def __init__(self, synchronize_unique_keys):
+    def __init__(self, synchronize_unique_keys, period = None):
         """
         Class constructor.
 
@@ -21,7 +23,9 @@ def __init__(self, synchronize_unique_keys):
         :type period: int
         """
 
-        self._task = AsyncTask(synchronize_unique_keys, _PERIOD,
+        if period == None:
+            period = _UNIQUE_KEYS_SYNC_PERIOD
+        self._task = AsyncTask(synchronize_unique_keys, period,
                                on_stop=synchronize_unique_keys)
 
     def start(self):
@@ -51,7 +55,7 @@ def flush(self):
 class ClearFilterSyncTask(BaseSynchronizationTask):
     """Unique Keys synchronization task uses an asynctask.AsyncTask to send MTKs."""
 
-    def __init__(self, clear_filter):
+    def __init__(self, clear_filter, period = None):
         """
         Class constructor.
 
@@ -60,8 +64,10 @@ def __init__(self, clear_filter):
         :param period: How many seconds to wait between subsequent clearing of bloom filter
         :type period: int
         """
-        _period = 60 * 60 * 24  # 24 hours
-        self._task = AsyncTask(clear_filter, _period,
+        if period == None:
+            period = _CLEAR_FILTER_SYNC_PERIOD
+
+        self._task = AsyncTask(clear_filter, period,
                                on_stop=clear_filter)
 
     def start(self):