polish and tests

Author: chillaq

splitio/client/factory.py

@@ -297,11 +297,11 @@ def _build_in_memory_factory(api_key, cfg, sdk_url=None, events_url=None,  # pyl
     if not input_validator.validate_factory_instantiation(api_key):
         return None
 
-    cfg['sdk_url'] = sdk_url if sdk_url is not None else None
-    cfg['events_url'] = events_url if events_url is not None else None
-    cfg['auth_url'] = auth_api_base_url if auth_api_base_url is not None else None
-    cfg['streaming_url'] = streaming_api_base_url if streaming_api_base_url is not None else None
-    cfg['telemetry_api_url'] = telemetry_api_base_url if telemetry_api_base_url is not None else None
+    cfg['sdk_url'] = sdk_url
+    cfg['events_url'] = events_url
+    cfg['auth_url'] = auth_api_base_url
+    cfg['streaming_url'] = streaming_api_base_url
+    cfg['telemetry_api_url'] = telemetry_api_base_url
 
     http_client = HttpClient(
         sdk_url=sdk_url,
@@ -551,9 +551,9 @@ def get_factory(api_key, **kwargs):
         redundant_factory_count = 0
         _INSTANTIATED_FACTORIES_LOCK.acquire()
         if _INSTANTIATED_FACTORIES:
+            active_factory_count = active_factory_count + 1
             if api_key in _INSTANTIATED_FACTORIES:
                 redundant_factory_count = redundant_factory_count + 1
-                active_factory_count = active_factory_count + 1
                 _LOGGER.warning(
                     "factory instantiation: You already have %d %s with this API Key. "
                     "We recommend keeping only one instance of the factory at all times "
@@ -562,7 +562,6 @@ def get_factory(api_key, **kwargs):
                     'factory' if _INSTANTIATED_FACTORIES[api_key] == 1 else 'factories'
                 )
             else:
-                active_factory_count = active_factory_count + 1
                 _LOGGER.warning(
                     "factory instantiation: You already have an instance of the Split factory. "
                     "Make sure you definitely want this additional instance. "
@@ -572,7 +571,7 @@ def get_factory(api_key, **kwargs):
 
         config = sanitize_config(api_key, kwargs.get('config', {}))
         config['redundantFactoryCount'] = redundant_factory_count
-        config['activeFactoryCount'] = active_factory_count + 1
+        config['activeFactoryCount'] = active_factory_count
 
         if config['operationMode'] == 'localhost-standalone':
             return _build_localhost_factory(config)

splitio/engine/telemetry.py

@@ -37,13 +37,13 @@ def record_ready_time(self, ready_time):
         """Record ready time."""
         self._telemetry_storage.record_ready_time(ready_time)
 
-    def record_bur_timeout(self):
+    def record_bur_time_out(self):
         """Record block until ready timeout."""
-        self._telemetry_storage.record_bur_timeout()
+        self._telemetry_storage.record_bur_time_out()
 
-    def record_non_ready_usage(self):
+    def record_not_ready_usage(self):
         """record non-ready usage."""
-        self._telemetry_storage.record_non_ready_usage()
+        self._telemetry_storage.record_not_ready_usage()
 
 class TelemetryEvaluationProducer(object):
     """Telemetry evaluation producer class."""
@@ -135,13 +135,13 @@ def __init__(self, telemetry_storage):
         """Constructor."""
         self._telemetry_storage = telemetry_storage
 
-    def get_bur_timeouts(self):
+    def get_bur_time_outs(self):
         """Get block until ready timeout."""
-        return self._telemetry_storage.get_bur_timeouts()
+        return self._telemetry_storage.get_bur_time_outs()
 
-    def get_non_ready_usage(self):
+    def get_not_ready_usage(self):
         """Get none-ready usage."""
-        return self._telemetry_storage.get_non_ready_usage()
+        return self._telemetry_storage.get_not_ready_usage()
 
     def get_config_stats(self):
         """Get none-ready usage."""

splitio/storage/__init__.py

@@ -288,7 +288,7 @@ class TelemetryStorage(object, metaclass=abc.ABCMeta):
     """Telemetry storage interface."""
 
     @abc.abstractmethod
-    def record_init(self, config):
+    def record_config(self, config):
         """
         initilize telemetry objects
 

splitio/storage/inmemmory.py

@@ -458,20 +458,27 @@ class InMemoryTelemetryStorage(TelemetryStorage):
 
     def __init__(self):
         """Constructor"""
+        self._reset_counters()
+        self._reset_latencies()
+        self._lock = threading.RLock()
+
+    def _reset_counters(self):
         self._counters = {'iQ': 0, 'iDe': 0, 'iDr': 0, 'eQ': 0, 'eD': 0, 'sL': 0,
                         'aR': 0, 'tR': 0}
-        self._latencies = {'mL': {'t': [], 'ts': [], 'tc': [], 'tcs': [], 'tr': []},
-                           'hL': {'sp': [], 'se': [], 'ms': [], 'im': [], 'ic': [], 'ev': [], 'te': [], 'to': []}}
         self._exceptions = {'mE': {'t': 0, 'ts': 0, 'tc': 0, 'tcs': 0, 'tr': 0}}
         self._records = {'IS': {'sp': 0, 'se': 0, 'ms': 0, 'im': 0, 'ic': 0, 'ev': 0, 'te': 0, 'to': 0},
                          'sL': 0}
         self._http_errors = {'sp': {}, 'se': {}, 'ms': {}, 'im': {}, 'ic': {}, 'ev': {}, 'te': {}, 'to': {}}
+        self._config = {'bT':0, 'nR':0, 'uC': 0}
         self._streaming_events = []
         self._tags = []
         self._integrations = {}
-        self._config = {'bT':0, 'nR':0, 'uC': 0}
+
+    def _reset_latencies(self):
+        self._latencies = {'mL': {'t': [], 'ts': [], 'tc': [], 'tcs': [], 'tr': []},
+                           'hL': {'sp': [], 'se': [], 'ms': [], 'im': [], 'ic': [], 'ev': [], 'te': [], 'to': []}}
         self._map_latencies = {'Treatment': 't', 'Treatments': 'ts', 'TreatmentWithConfig': 'tc', 'TreatmentsWithConfig': 'tcs', 'Track': 'tr'}
-        self._lock = threading.RLock()
+
 
     def record_config(self, config):
         """Record configurations."""
@@ -497,26 +504,26 @@ def record_ready_time(self, ready_time):
     def add_tag(self, tag):
         """Record tag string."""
         with self._lock:
-            if len(self._tags) <= MAX_TAGS:
+            if len(self._tags) < MAX_TAGS:
                 self._tags.append(tag)
 
-    def record_bur_timeout(self):
+    def record_bur_time_out(self):
         """Record block until ready timeout."""
         with self._lock:
             self._config['bT'] = self._config['bT'] + 1
 
-    def record_non_ready_usage(self):
+    def record_not_ready_usage(self):
         """record non-ready usage."""
         with self._lock:
             self._config['nR'] = self._config['nR'] + 1
 
     def record_latency(self, method, latency):
         """Record method latency time."""
         with self._lock:
-            if self._latencies['mL'][self._map_latencies[method]] < MAX_LATENCY_BUCKET_COUNT:
+            if len(self._latencies['mL'][self._map_latencies[method]]) < MAX_LATENCY_BUCKET_COUNT:
                 self._latencies['mL'][self._map_latencies[method]].append(latency)
 
-    def record_exceptions(self, method):
+    def record_exception(self, method):
         """Record method exception."""
         with self._lock:
             self._exceptions['mE'][self._map_latencies[method]] = self._exceptions['mE'][self._map_latencies[method]] + 1
@@ -539,13 +546,15 @@ def record_suceessful_sync(self, resource, time):
     def record_sync_error(self, resource, status):
         """Record sync http error."""
         with self._lock:
+            if status not in self._http_errors[resource]:
+                self._http_errors[resource][status] = 0
             self._http_errors[resource][status] = self._http_errors[resource][status] + 1
 
     def record_sync_latency(self, resource, latency):
         """Record latency time."""
         with self._lock:
-            if self._latencies['hL'][self._map_latencies[resource]] < MAX_LATENCY_BUCKET_COUNT:
-                self._latencies['hL'][self._map_latencies[resource]].append(latency)
+            if len(self._latencies['hL'][resource]) < MAX_LATENCY_BUCKET_COUNT:
+                self._latencies['hL'][resource].append(latency)
 
     def record_auth_rejections(self):
         """Record auth rejection."""
@@ -561,14 +570,14 @@ def record_streaming_event(self, streaming_event):
         """Record incoming streaming event."""
         with self._lock:
             if len(self._streaming_events) < MAX_STREAMING_EVENTS:
-                self._streaming_events.append({'e': streaming_event.type, 'd': streaming_event.data, 't': streaming_event.time})
+                self._streaming_events.append({'e': streaming_event['type'], 'd': streaming_event['data'], 't': streaming_event['time']})
 
     def record_session_length(self, session):
         """Record session length."""
         with self._lock:
             self._records['sL'] = session
 
-    def get_bur_timeouts(self):
+    def get_bur_time_outs(self):
         """Get block until ready timeout."""
         with self._lock:
             return self._config['bT']
@@ -680,21 +689,21 @@ def _get_storage_type(self, op_mode):
     def _get_refresh_rates(self, config):
         with self._lock:
             rr = {}
-            rr['sp'] == config['featuresRefreshRate']
-            rr['se'] == config['segmentsRefreshRate']
-            rr['im'] == config['impressionsRefreshRate']
-            rr['ev'] == config['eventsPushRate']
-            rr['te'] == config['metrcsRefreshRate']
+            rr['sp'] = config['featuresRefreshRate']
+            rr['se'] = config['segmentsRefreshRate']
+            rr['im'] = config['impressionsRefreshRate']
+            rr['ev'] = config['eventsPushRate']
+            rr['te'] = config['metrcsRefreshRate']
             return rr
 
     def _get_url_overrides(self, config):
         with self._lock:
             rr = {}
-            rr['s'] == True if config['sdk_url'] is not None else False
-            rr['e'] == True if config['events_url'] is not None else False
-            rr['a'] == True if config['auth_url'] is not None else False
-            rr['st'] == True if config['streaming_url'] is not None else False
-            rr['t'] == True if config['telemetry_url'] is not None else False
+            rr['s'] == True if 'sdk_url' in config else False
+            rr['e'] == True if 'events_url' in config else False
+            rr['a'] == True if 'auth_url' in config else False
+            rr['st'] == True if 'streaming_url' in config else False
+            rr['t'] == True if 'telemetry_url' in config else False
             return rr
 
     def _get_impressions_mode(self, imp_mode):

splitio/sync/telemetry.py

@@ -6,17 +6,17 @@
 class TelemetrySynchronizer(object):
     """Telemetry synchronizer class."""
 
-    def __init__(self, telemetry_consumer, telemetry_api):
+    def __init__(self, telemetry_consumer, split_storage, segment_storage, telemetry_api):
         """Initialize Telemetry sync class."""
-        self._telemetry_submitter = TelemetrySubmitter(telemetry_consumer, telemetry_api)
+        self._telemetry_submitter = TelemetrySubmitter(telemetry_consumer, split_storage, segment_storage, telemetry_api)
 
     def synchronize_config(self):
         """synchronize initial config data class."""
-        self._telemetry_submitter.Synchronize_config()
+        self._telemetry_submitter.synchronize_config()
 
     def synchronize_stats(self):
         """synchronize runtime stats class."""
-        self._telemetry_submitter.Synchronize_stats()
+        self._telemetry_submitter.synchronize_stats()
 
 class TelemetrySubmitter(object):
     """Telemetry sumbitter class."""
@@ -30,13 +30,13 @@ def __init__(self, telemetry_consumer, split_storage, segment_storage, telemetry
         self._split_storage = split_storage
         self._segment_storage = segment_storage
 
-    def Synchronize_config(self):
+    def synchronize_config(self):
         """synchronize initial config data classe."""
         self._telemetry_api.record_init(json.dumps(self._telemetry_init_consumer.get_config_stats()))
 
     def synchronize_stats(self):
         """synchronize runtime stats class."""
-        self._telemetry_api.record_stats(json.dumps(
+        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')},
@@ -55,4 +55,4 @@ def synchronize_stats(self):
             **{'spC': self._split_storage.get_splits_count()},
             **{'seC': self._segment_storage.get_segments_count()},
             **{'skC': self._segment_storage.get_segments_keys_count()},
-        ))
+        }))