cleanup

Author: chillaq

splitio/client/factory.py

@@ -16,7 +16,7 @@
 from splitio.engine.impressions.manager import Counter as ImpressionsCounter
 from splitio.engine.impressions.strategies import StrategyNoneMode, StrategyDebugMode, StrategyOptimizedMode
 from splitio.engine.impressions.adapters import InMemorySenderAdapter, RedisSenderAdapter
-from splitio.engine.telemetry import TelemetryStorageProducer, TelemetryStorageConsumer, RedisTelemetryInitProducer, RedisTelemetryStorageProducer
+from splitio.engine.telemetry import TelemetryStorageProducer, TelemetryStorageConsumer
 
 # Storage
 from splitio.storage.inmemmory import InMemorySplitStorage, InMemorySegmentStorage, \
@@ -160,8 +160,9 @@ def _start_status_updater(self):
     def _update_redis_init(self):
         """Push Config Telemetry into redis storage"""
         redundant_factory_count, active_factory_count = _get_active_and_redundant_count()
-        self._telemetry_init_producer.record_active_and_redundant_factories(active_factory_count, redundant_factory_count)
-        self._telemetry_init_producer.push_config()
+        self._storages['telemetry'].record_active_and_redundant_factories(active_factory_count, redundant_factory_count)
+        self._storages['telemetry'].push_config_stats()
+
 
     def _update_status_when_ready(self):
         """Wait until the sdk is ready and update the status."""
@@ -448,16 +449,16 @@ def _build_redis_factory(api_key, cfg):
     redis_adapter = redis.build(cfg)
     cache_enabled = cfg.get('redisLocalCacheEnabled', False)
     cache_ttl = cfg.get('redisLocalCacheTTL', 5)
-    telemetry_storage = RedisTelemetryStorage(redis_adapter, sdk_metadata)
-    telemetry_producer = RedisTelemetryStorageProducer(telemetry_storage)
-    telemetry_consumer = TelemetryStorageConsumer(telemetry_storage)
-    telemetry_runtime_producer = telemetry_producer.get_telemetry_runtime_producer()
     storages = {
         'splits': RedisSplitStorage(redis_adapter, cache_enabled, cache_ttl),
         'segments': RedisSegmentStorage(redis_adapter),
         'impressions': RedisImpressionsStorage(redis_adapter, sdk_metadata),
-        'events': RedisEventsStorage(redis_adapter, sdk_metadata)
+        'events': RedisEventsStorage(redis_adapter, sdk_metadata),
+        'telemetry': RedisTelemetryStorage(redis_adapter, sdk_metadata)
     }
+    telemetry_producer = TelemetryStorageProducer(storages['telemetry'])
+    telemetry_consumer = TelemetryStorageConsumer(storages['telemetry'])
+    telemetry_runtime_producer = telemetry_producer.get_telemetry_runtime_producer()
 
     data_sampling = cfg.get('dataSampling', DEFAULT_DATA_SAMPLING)
     if data_sampling < _MIN_DEFAULT_DATA_SAMPLING_ALLOWED:
@@ -495,7 +496,7 @@ def _build_redis_factory(api_key, cfg):
         imp_manager,
         storages['events'],
         storages['impressions'],
-        telemetry_storage,
+        storages['telemetry'],
         data_sampling,
     )
 

splitio/engine/telemetry.py

@@ -292,54 +292,3 @@ def pop_formatted_stats(self):
                       } for event in self.pop_streaming_events()['streamingEvents']],
             'sL': self.get_session_length()
         }
-
-class RedisTelemetryStorageProducer(object):
-    """Telemetry storage producer class."""
-
-    def __init__(self, telemetry_storage):
-        """Initialize all producer classes."""
-        self._telemetry_init_producer = RedisTelemetryInitProducer(telemetry_storage)
-        self._telemetry_evaluation_producer = TelemetryEvaluationProducer(telemetry_storage)
-        self._telemetry_runtime_producer = TelemetryRuntimeProducer(telemetry_storage)
-
-    def get_telemetry_init_producer(self):
-        """get init producer instance."""
-        return self._telemetry_init_producer
-
-    def get_telemetry_evaluation_producer(self):
-        """get evaluation producer instance."""
-        return self._telemetry_evaluation_producer
-
-    def get_telemetry_runtime_producer(self):
-        """get runtime producer instance."""
-        return self._telemetry_runtime_producer
-
-class RedisTelemetryInitProducer(object):
-    """Telemetry init producer class."""
-
-    def __init__(self, telemetry_storage):
-        """Constructor."""
-        self._telemetry_storage = telemetry_storage
-
-    def record_config(self, config, extra_config):
-        """Record configurations."""
-        self._telemetry_storage.record_config(config, extra_config)
-
-    def push_config(self):
-        """Record configurations."""
-        self._telemetry_storage.push_config_stats()
-
-    def record_ready_time(self, ready_time):
-        """Record ready time."""
-        pass
-
-    def record_bur_time_out(self):
-        """Record block until ready timeout."""
-        pass
-
-    def record_not_ready_usage(self):
-        """record non-ready usage."""
-        pass
-
-    def record_active_and_redundant_factories(self, active_factory_count, redundant_factory_count):
-        self._telemetry_storage.record_active_and_redundant_factories(active_factory_count, redundant_factory_count)

tests/storage/test_redis.py

@@ -404,7 +404,7 @@ def test_record_config(self, mocker):
         redis_telemetry.record_config(mocker.Mock(), mocker.Mock())
         assert(mocker.called)
 
-    @mock.patch('splitio.storage.adapters.redis.RedisAdapter.record_init')
+    @mock.patch('splitio.storage.adapters.redis.RedisAdapter.hset')
     def test_push_config_stats(self, mocker):
         adapter = build({})
         redis_telemetry = RedisTelemetryStorage(adapter, mocker.Mock())