polishing

Author: chillaq

splitio/client/factory.py

@@ -292,12 +292,13 @@ def _wrap_impression_listener(listener, metadata):
     return None
 
 
-def _build_in_memory_factory(api_key, cfg, extra_cfg, sdk_url=None, events_url=None,  # pylint:disable=too-many-arguments,too-many-locals
+def _build_in_memory_factory(api_key, cfg, sdk_url=None, events_url=None,  # pylint:disable=too-many-arguments,too-many-locals
                              auth_api_base_url=None, streaming_api_base_url=None, telemetry_api_base_url=None):
     """Build and return a split factory tailored to the supplied config."""
     if not input_validator.validate_factory_instantiation(api_key):
         return None
 
+    extra_cfg = {}
     extra_cfg['sdk_url'] = sdk_url
     extra_cfg['events_url'] = events_url
     extra_cfg['auth_url'] = auth_api_base_url
@@ -524,7 +525,6 @@ def get_factory(api_key, **kwargs):
                 )
 
         config = sanitize_config(api_key, kwargs.get('config', {}))
-        extra_config = {}
 
         if config['operationMode'] == 'localhost-standalone':
             return _build_localhost_factory(config)
@@ -535,20 +535,22 @@ def get_factory(api_key, **kwargs):
         return _build_in_memory_factory(
             api_key,
             config,
-            extra_config,
             kwargs.get('sdk_api_base_url'),
             kwargs.get('events_api_base_url'),
             kwargs.get('auth_api_base_url'),
             kwargs.get('streaming_api_base_url'),
             kwargs.get('telemetry_api_base_url')
         )
     finally:
-        redundant_factory_count = 0
-        active_factory_count = 0
         _INSTANTIATED_FACTORIES.update([api_key])
-        for item in _INSTANTIATED_FACTORIES:
-            redundant_factory_count = redundant_factory_count + _INSTANTIATED_FACTORIES[item] - 1
-            active_factory_count = active_factory_count + _INSTANTIATED_FACTORIES[item]
-        extra_config['redundant_factory_count'] = redundant_factory_count
-        extra_config['active_factory_count'] = active_factory_count
         _INSTANTIATED_FACTORIES_LOCK.release()
+
+def _get_active_and_derundant_count():
+    redundant_factory_count = 0
+    active_factory_count = 0
+    _INSTANTIATED_FACTORIES_LOCK.acquire()
+    for item in _INSTANTIATED_FACTORIES:
+        redundant_factory_count = redundant_factory_count + _INSTANTIATED_FACTORIES[item] - 1
+        active_factory_count = active_factory_count + _INSTANTIATED_FACTORIES[item]
+    _INSTANTIATED_FACTORIES_LOCK.release()
+    return redundant_factory_count, active_factory_count

splitio/engine/telemetry.py

@@ -1,4 +1,6 @@
 """Telemetry engine classes."""
+import json
+
 from  splitio.storage.inmemmory import InMemoryTelemetryStorage
 
 class TelemetryStorageProducer(object):
@@ -147,6 +149,9 @@ def get_config_stats(self):
         """Get none-ready usage."""
         return self._telemetry_storage.get_config_stats()
 
+    def get_config_stats_to_json(self):
+        return json.dumps(self._telemetry_storage.get_config_stats())
+
 class TelemetryEvaluationConsumer(object):
     """Telemetry evaluation consumer class."""
 
@@ -162,6 +167,14 @@ def pop_latencies(self):
         """Get and reset eval latencies."""
         return self._telemetry_storage.pop_latencies()
 
+    def pop_formatted_stats(self):
+        """Get formatted and reset stats."""
+        return {
+            **{'mE': self.pop_exceptions()},
+            **{'mL': self.pop_latencies()},
+        }
+
+
 class TelemetryRuntimeConsumer(object):
     """Telemetry runtime consumer class."""
 
@@ -208,3 +221,21 @@ def pop_streaming_events(self):
     def get_session_length(self):
         """Get session length"""
         return self._telemetry_storage.get_session_length()
+
+    def pop_formatted_stats(self):
+        """Get formatted and reset stats."""
+        return {
+            **{'iQ': self.get_impressions_stats('iQ')},
+            **{'iDe': self.get_impressions_stats('iDe')},
+            **{'iDr': self.get_impressions_stats('iDr')},
+            **{'eQ': self.get_events_stats('eQ')},
+            **{'eD': self.get_events_stats('eD')},
+            **{'IS': self.get_last_synchronization()},
+            **{'t': self.pop_tags()},
+            **{'hE': self.pop_http_errors()},
+            **{'hL': self.pop_http_latencies()},
+            **{'aR': self.pop_auth_rejections()},
+            **{'tR': self.pop_token_refreshes()},
+            **{'sE': self.pop_streaming_events()},
+            **{'sL': self.get_session_length()}
+        }

splitio/sync/telemetry.py

@@ -32,27 +32,18 @@ def __init__(self, telemetry_consumer, split_storage, segment_storage, telemetry
 
     def synchronize_config(self):
         """synchronize initial config data classe."""
-        self._telemetry_api.record_init(json.dumps(self._telemetry_init_consumer.get_config_stats()))
+        self._telemetry_api.record_init(self._telemetry_init_consumer.get_config_stats_to_json())
 
     def synchronize_stats(self):
         """synchronize runtime stats class."""
-        self._telemetry_api.record_stats(json.dumps({
-            **{'iQ': self._telemetry_runtime_consumer.get_impressions_stats('iQ')},
-            **{'iDe': self._telemetry_runtime_consumer.get_impressions_stats('iDe')},
-            **{'iDr': self._telemetry_runtime_consumer.get_impressions_stats('iDr')},
-            **{'eQ': self._telemetry_runtime_consumer.get_events_stats('eQ')},
-            **{'eD': self._telemetry_runtime_consumer.get_events_stats('eD')},
-            **{'IS': self._telemetry_runtime_consumer.get_last_synchronization()},
-            **{'t': self._telemetry_runtime_consumer.pop_tags()},
-            **{'hE': self._telemetry_runtime_consumer.pop_http_errors()},
-            **{'hL': self._telemetry_runtime_consumer.pop_http_latencies()},
-            **{'aR': self._telemetry_runtime_consumer.pop_auth_rejections()},
-            **{'tR': self._telemetry_runtime_consumer.pop_token_refreshes()},
-            **{'sE': self._telemetry_runtime_consumer.pop_streaming_events()},
-            **{'sL': self._telemetry_runtime_consumer.get_session_length()},
-            **{'mE': self._telemetry_evaluation_consumer.pop_exceptions()},
-            **{'mL': self._telemetry_evaluation_consumer.pop_latencies()},
+        self._telemetry_api.record_stats(self._build_stats())
+
+    def _build_stats(self):
+        """Format stats to JSON."""
+        return json.dumps({
+            **self._telemetry_runtime_consumer.pop_formatted_stats(),
+            **self._telemetry_evaluation_consumer.pop_formatted_stats(),
             **{'spC': self._split_storage.get_splits_count()},
             **{'seC': self._segment_storage.get_segments_count()},
             **{'skC': self._segment_storage.get_segments_keys_count()},
-        }))
+        })