splitio-client 9.5.1__tar.gz → 9.6.1__tar.gz

{splitio_client-9.5.1 → splitio_client-9.6.1}/PKG-INFO

@@ -1,12 +1,12 @@
 Metadata-Version: 2.1
 Name: splitio_client
-Version: 9.5.1
+Version: 9.6.1
 Summary: Split.io Python Client
 Home-page: https://github.com/splitio/python-client
 Author: Patricio Echague, Sebastian Arrubia
 Author-email: pato@split.io, sebastian@split.io
 License: Apache License 2.0
-Download-URL: https://github.com/splitio/python-client/tarball/9.5.1
+Download-URL: https://github.com/splitio/python-client/tarball/9.6.1
 Description: UNKNOWN
 Platform: UNKNOWN
 Classifier: Environment :: Console
@@ -15,7 +15,7 @@ Classifier: Programming Language :: Python
 Classifier: Programming Language :: Python :: 2
 Classifier: Programming Language :: Python :: 3
 Classifier: Topic :: Software Development :: Libraries
+Provides-Extra: test
 Provides-Extra: redis
 Provides-Extra: uwsgi
-Provides-Extra: test
 Provides-Extra: cpphash

{splitio_client-9.5.1 → splitio_client-9.6.1}/splitio/api/commons.py

@@ -57,7 +57,7 @@ def record_telemetry(status_code, elapsed, metric_name, telemetry_runtime_produc
 class FetchOptions(object):
     """Fetch Options object."""
 
-    def __init__(self, cache_control_headers=False, change_number=None):
+    def __init__(self, cache_control_headers=False, change_number=None, sets=None):
         """
         Class constructor.
 
@@ -66,9 +66,13 @@ class FetchOptions(object):
 
         :param change_number: ChangeNumber to use for bypassing CDN in request.
         :type change_number: int
+
+        :param sets: list of flag sets
+        :type sets: list
         """
         self._cache_control_headers = cache_control_headers
         self._change_number = change_number
+        self._sets = sets
 
     @property
     def cache_control_headers(self):
@@ -80,12 +84,19 @@ class FetchOptions(object):
         """Return change number."""
         return self._change_number
 
+    @property
+    def sets(self):
+        """Return sets."""
+        return self._sets
+
     def __eq__(self, other):
         """Match between other options."""
         if self._cache_control_headers != other._cache_control_headers:
             return False
         if self._change_number != other._change_number:
             return False
+        if self._sets != other._sets:
+            return False
         return True
 
 
@@ -113,4 +124,6 @@ def build_fetch(change_number, fetch_options, metadata):
         extra_headers[_CACHE_CONTROL] = _CACHE_CONTROL_NO_CACHE
     if fetch_options.change_number is not None:
         query['till'] = fetch_options.change_number
+    if fetch_options.sets is not None:
+        query['sets'] = fetch_options.sets
     return query, extra_headers

{splitio_client-9.5.1 → splitio_client-9.6.1}/splitio/api/splits.py

@@ -59,6 +59,8 @@ class SplitsAPI(object):  # pylint: disable=too-few-public-methods
             if 200 <= response.status_code < 300:
                 return json.loads(response.body)
             else:
+                if response.status_code == 414:
+                    _LOGGER.error('Error fetching feature flags; the amount of flag sets provided are too big, causing uri length error.')
                 raise APIException(response.body, response.status_code)
         except HttpClientException as exc:
             _LOGGER.error('Error fetching feature flags because an exception was raised by the HTTPClient')

{splitio_client-9.5.1 → splitio_client-9.6.1}/splitio/api/telemetry.py

@@ -76,7 +76,6 @@ class TelemetryAPI(object):  # pylint: disable=too-few-public-methods
                 'Error posting init config because an exception was raised by the HTTPClient'
             )
             _LOGGER.debug('Error: ', exc_info=True)
-            raise APIException('Init config data not flushed properly.') from exc
 
     def record_stats(self, stats):
         """

{splitio_client-9.5.1 → splitio_client-9.6.1}/splitio/client/client.py

@@ -6,7 +6,7 @@ from splitio.engine.splitters import Splitter
 from splitio.models.impressions import Impression, Label
 from splitio.models.events import Event, EventWrapper
 from splitio.models.telemetry import get_latency_bucket_index, MethodExceptionsAndLatencies
-from splitio.client import input_validator
+from splitio.client import input_validator, config
 from splitio.util.time import get_current_epoch_time_ms, utctime_ms
 
 _LOGGER = logging.getLogger(__name__)
@@ -59,8 +59,9 @@ class Client(object):  # pylint: disable=too-many-instance-attributes
         """Return whether the factory holding this client has been destroyed."""
         return self._factory.destroyed
 
-    def _evaluate_if_ready(self, matching_key, bucketing_key, feature, attributes=None):
+    def _evaluate_if_ready(self, matching_key, bucketing_key, feature, method, attributes=None):
         if not self.ready:
+            _LOGGER.warning("%s: The SDK is not ready, results may be incorrect for feature flag %s. Make sure to wait for SDK readiness before using this method", method, feature)
             self._telemetry_init_producer.record_not_ready_usage()
             return {
                 'treatment': CONTROL,
@@ -102,7 +103,7 @@ class Client(object):  # pylint: disable=too-many-instance-attributes
                     or not input_validator.validate_attributes(attributes, method_name):
                 return CONTROL, None
 
-            result = self._evaluate_if_ready(matching_key, bucketing_key, feature_flag, attributes)
+            result = self._evaluate_if_ready(matching_key, bucketing_key, feature_flag, method_name, attributes)
 
             impression = self._build_impression(
                 matching_key,
@@ -167,7 +168,7 @@ class Client(object):  # pylint: disable=too-many-instance-attributes
 
         try:
             evaluations = self._evaluate_features_if_ready(matching_key, bucketing_key,
-                                                           list(feature_flags), attributes)
+                                                           list(feature_flags), method_name, attributes)
 
             for feature_flag in feature_flags:
                 try:
@@ -212,8 +213,9 @@ class Client(object):  # pylint: disable=too-many-instance-attributes
             _LOGGER.debug('Error: ', exc_info=True)
         return input_validator.generate_control_treatments(list(feature_flags), method_name)
 
-    def _evaluate_features_if_ready(self, matching_key, bucketing_key, feature_flags, attributes=None):
+    def _evaluate_features_if_ready(self, matching_key, bucketing_key, feature_flags, method, attributes=None):
         if not self.ready:
+            _LOGGER.warning("%s: The SDK is not ready, results may be incorrect for feature flags %s. Make sure to wait for SDK readiness before using this method", method, ', '.join([feature for feature in feature_flags]))
             self._telemetry_init_producer.record_not_ready_usage()
             return {
                 feature_flag: {
@@ -309,6 +311,132 @@ class Client(object):  # pylint: disable=too-many-instance-attributes
                                              MethodExceptionsAndLatencies.TREATMENTS)
         return {feature_flag: result[0] for (feature_flag, result) in with_config.items()}
 
+    def get_treatments_by_flag_set(self, key, flag_set, attributes=None):
+        """
+        Get treatments for feature flags that contain given flag set.
+
+        This method never raises an exception. If there's a problem, the appropriate log message
+        will be generated and the method will return the CONTROL treatment.
+
+        :param key: The key for which to get the treatment
+        :type key: str
+        :param flag_set: flag set
+        :type flag_sets: str
+        :param attributes: An optional dictionary of attributes
+        :type attributes: dict
+
+        :return: Dictionary with the result of all the feature flags provided
+        :rtype: dict
+        """
+        return self._get_treatments_by_flag_sets( key, [flag_set], MethodExceptionsAndLatencies.TREATMENTS_BY_FLAG_SET, attributes)
+
+    def get_treatments_by_flag_sets(self, key, flag_sets, attributes=None):
+        """
+        Get treatments for feature flags that contain given flag sets.
+
+        This method never raises an exception. If there's a problem, the appropriate log message
+        will be generated and the method will return the CONTROL treatment.
+
+        :param key: The key for which to get the treatment
+        :type key: str
+        :param flag_sets: list of flag sets
+        :type flag_sets: list
+        :param attributes: An optional dictionary of attributes
+        :type attributes: dict
+
+        :return: Dictionary with the result of all the feature flags provided
+        :rtype: dict
+        """
+        return self._get_treatments_by_flag_sets( key, flag_sets, MethodExceptionsAndLatencies.TREATMENTS_BY_FLAG_SETS, attributes)
+
+    def get_treatments_with_config_by_flag_set(self, key, flag_set, attributes=None):
+        """
+        Get treatments for feature flags that contain given flag set.
+
+        This method never raises an exception. If there's a problem, the appropriate log message
+        will be generated and the method will return the CONTROL treatment.
+
+        :param key: The key for which to get the treatment
+        :type key: str
+        :param flag_set: flag set
+        :type flag_sets: str
+        :param attributes: An optional dictionary of attributes
+        :type attributes: dict
+
+        :return: Dictionary with the result of all the feature flags provided
+        :rtype: dict
+        """
+        return self._get_treatments_by_flag_sets( key, [flag_set], MethodExceptionsAndLatencies.TREATMENTS_WITH_CONFIG_BY_FLAG_SET, attributes)
+
+    def get_treatments_with_config_by_flag_sets(self, key, flag_sets, attributes=None):
+        """
+        Get treatments for feature flags that contain given flag set.
+
+        This method never raises an exception. If there's a problem, the appropriate log message
+        will be generated and the method will return the CONTROL treatment.
+
+        :param key: The key for which to get the treatment
+        :type key: str
+        :param flag_set: flag set
+        :type flag_sets: str
+        :param attributes: An optional dictionary of attributes
+        :type attributes: dict
+
+        :return: Dictionary with the result of all the feature flags provided
+        :rtype: dict
+        """
+        return self._get_treatments_by_flag_sets( key, flag_sets, MethodExceptionsAndLatencies.TREATMENTS_WITH_CONFIG_BY_FLAG_SETS, attributes)
+
+    def _get_treatments_by_flag_sets(self, key, flag_sets, method, attributes=None):
+        """
+        Get treatments for feature flags that contain given flag sets.
+
+        This method never raises an exception. If there's a problem, the appropriate log message
+        will be generated and the method will return the CONTROL treatment.
+
+        :param key: The key for which to get the treatment
+        :type key: str
+        :param flag_sets: list of flag sets
+        :type flag_sets: list
+        :param method: Treatment by flag set method flavor
+        :type method: splitio.models.telemetry.MethodExceptionsAndLatencies
+        :param attributes: An optional dictionary of attributes
+        :type attributes: dict
+
+        :return: Dictionary with the result of all the feature flags provided
+        :rtype: dict
+        """
+        feature_flags_names = self._get_feature_flag_names_by_flag_sets(flag_sets, method.value)
+        if feature_flags_names == []:
+            _LOGGER.warning("%s: No valid Flag set or no feature flags found for evaluating treatments" % (method.value))
+            return {}
+
+        if 'config' in method.value:
+            return self._make_evaluations(key, feature_flags_names, attributes, method.value,
+                                      method)
+
+        with_config = self._make_evaluations(key, feature_flags_names, attributes, method.value,
+                                             method)
+        return {feature_flag: result[0] for (feature_flag, result) in with_config.items()}
+
+
+    def _get_feature_flag_names_by_flag_sets(self, flag_sets, method_name):
+        """
+        Sanitize given flag sets and return list of feature flag names associated with them
+
+        :param flag_sets: list of flag sets
+        :type flag_sets: list
+
+        :return: list of feature flag names
+        :rtype: list
+        """
+        sanitized_flag_sets = input_validator.validate_flag_sets(flag_sets, method_name)
+        feature_flags_by_set = self._split_storage.get_feature_flags_by_sets(sanitized_flag_sets)
+        if feature_flags_by_set is None:
+            _LOGGER.warning("Fetching feature flags for flag set %s encountered an error, skipping this flag set." % (flag_sets))
+            return []
+        return feature_flags_by_set
+
     def _build_impression(  # pylint: disable=too-many-arguments
             self,
             matching_key,

{splitio_client-9.5.1 → splitio_client-9.6.1}/splitio/client/config.py

@@ -3,12 +3,12 @@ import os.path
 import logging
 
 from splitio.engine.impressions import ImpressionsMode
+from splitio.client.input_validator import validate_flag_sets
 
 
 _LOGGER = logging.getLogger(__name__)
 DEFAULT_DATA_SAMPLING = 1
 
-
 DEFAULT_CONFIG = {
     'operationMode': 'standalone',
     'connectionTimeout': 1500,
@@ -31,6 +31,7 @@ DEFAULT_CONFIG = {
     'redisHost': 'localhost',
     'redisPort': 6379,
     'redisDb': 0,
+    'redisUsername': None,
     'redisPassword': None,
     'redisSocketTimeout': None,
     'redisSocketConnectTimeout': None,
@@ -58,10 +59,10 @@ DEFAULT_CONFIG = {
     'dataSampling': DEFAULT_DATA_SAMPLING,
     'storageWrapper': None,
     'storagePrefix': None,
-    'storageType': None
+    'storageType': None,
+    'flagSetsFilter': None
 }
 
-
 def _parse_operation_mode(sdk_key, config):
     """
     Process incoming config to determine operation mode and storage type
@@ -118,7 +119,6 @@ def _sanitize_impressions_mode(storage_type, mode, refresh_rate=None):
 
     return mode, refresh_rate
 
-
 def sanitize(sdk_key, config):
     """
     Look for inconsistencies or ill-formed configs and tune it accordingly.
@@ -143,4 +143,10 @@ def sanitize(sdk_key, config):
         _LOGGER.warning('metricRefreshRate parameter minimum value is 60 seconds, defaulting to 3600 seconds.')
         processed['metricsRefreshRate'] = 3600
 
+    if config['operationMode'] == 'consumer' and config.get('flagSetsFilter') is not None:
+        processed['flagSetsFilter'] = None
+        _LOGGER.warning('config: FlagSets filter is not applicable for Consumer modes where the SDK does keep rollout data in sync. FlagSet filter was discarded.')
+    else:
+        processed['flagSetsFilter'] = sorted(validate_flag_sets(processed['flagSetsFilter'], 'SDK Config')) if processed['flagSetsFilter'] is not None else None
+
     return processed

{splitio_client-9.5.1 → splitio_client-9.6.1}/splitio/client/factory.py

@@ -312,7 +312,8 @@ def _wrap_impression_listener(listener, metadata):
 
 
 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):
+                             auth_api_base_url=None, streaming_api_base_url=None, telemetry_api_base_url=None,
+                             total_flag_sets=0, invalid_flag_sets=0):
     """Build and return a split factory tailored to the supplied config."""
     if not input_validator.validate_factory_instantiation(api_key):
         return None
@@ -350,7 +351,7 @@ def _build_in_memory_factory(api_key, cfg, sdk_url=None, events_url=None,  # pyl
     }
 
     storages = {
-        'splits': InMemorySplitStorage(),
+        'splits': InMemorySplitStorage(cfg['flagSetsFilter'] if cfg['flagSetsFilter'] is not None else []),
         'segments': InMemorySegmentStorage(),
         'impressions': InMemoryImpressionStorage(cfg['impressionsQueueSize'], telemetry_runtime_producer),
         'events': InMemoryEventStorage(cfg['eventsQueueSize'], telemetry_runtime_producer),
@@ -416,7 +417,7 @@ def _build_in_memory_factory(api_key, cfg, sdk_url=None, events_url=None,  # pyl
         telemetry_evaluation_producer
     )
 
-    telemetry_init_producer.record_config(cfg, extra_cfg)
+    telemetry_init_producer.record_config(cfg, extra_cfg, total_flag_sets, invalid_flag_sets)
 
     if preforked_initialization:
         synchronizer.sync_all(max_retry_attempts=_MAX_RETRY_SYNC_ALL)
@@ -440,7 +441,7 @@ def _build_redis_factory(api_key, cfg):
     cache_enabled = cfg.get('redisLocalCacheEnabled', False)
     cache_ttl = cfg.get('redisLocalCacheTTL', 5)
     storages = {
-        'splits': RedisSplitStorage(redis_adapter, cache_enabled, cache_ttl),
+        'splits': RedisSplitStorage(redis_adapter, cache_enabled, cache_ttl, []),
         'segments': RedisSegmentStorage(redis_adapter),
         'impressions': RedisImpressionsStorage(redis_adapter, sdk_metadata),
         'events': RedisEventsStorage(redis_adapter, sdk_metadata),
@@ -495,7 +496,7 @@ def _build_redis_factory(api_key, cfg):
     initialization_thread = threading.Thread(target=manager.start, name="SDKInitializer", daemon=True)
     initialization_thread.start()
 
-    telemetry_init_producer.record_config(cfg, {})
+    telemetry_init_producer.record_config(cfg, {}, 0, 0)
 
     split_factory = SplitFactory(
         api_key,
@@ -523,7 +524,7 @@ def _build_pluggable_factory(api_key, cfg):
     pluggable_adapter = cfg.get('storageWrapper')
     storage_prefix = cfg.get('storagePrefix')
     storages = {
-        'splits': PluggableSplitStorage(pluggable_adapter, storage_prefix),
+        'splits': PluggableSplitStorage(pluggable_adapter, storage_prefix, []),
         'segments': PluggableSegmentStorage(pluggable_adapter, storage_prefix),
         'impressions': PluggableImpressionsStorage(pluggable_adapter, sdk_metadata, storage_prefix),
         'events': PluggableEventsStorage(pluggable_adapter, sdk_metadata, storage_prefix),
@@ -573,7 +574,7 @@ def _build_pluggable_factory(api_key, cfg):
     initialization_thread = threading.Thread(target=manager.start, name="SDKInitializer", daemon=True)
     initialization_thread.start()
 
-    telemetry_init_producer.record_config(cfg, {})
+    telemetry_init_producer.record_config(cfg, {}, 0, 0)
 
     split_factory = SplitFactory(
         api_key,
@@ -600,7 +601,7 @@ def _build_localhost_factory(cfg):
     telemetry_evaluation_producer = telemetry_producer.get_telemetry_evaluation_producer()
 
     storages = {
-        'splits': InMemorySplitStorage(),
+        'splits': InMemorySplitStorage(cfg['flagSetsFilter'] if cfg['flagSetsFilter'] is not None else []),
         'segments': InMemorySegmentStorage(),  # not used, just to avoid possible future errors.
         'impressions': LocalhostImpressionsStorage(),
         'events': LocalhostEventsStorage(),
@@ -684,7 +685,14 @@ def get_factory(api_key, **kwargs):
     _INSTANTIATED_FACTORIES.update([api_key])
     _INSTANTIATED_FACTORIES_LOCK.release()
 
-    config = sanitize_config(api_key, kwargs.get('config', {}))
+    config_raw = kwargs.get('config', {})
+    total_flag_sets = 0
+    invalid_flag_sets = 0
+    if config_raw.get('flagSetsFilter') is not None and isinstance(config_raw.get('flagSetsFilter'), list):
+        total_flag_sets = len(config_raw.get('flagSetsFilter'))
+        invalid_flag_sets = total_flag_sets - len(input_validator.validate_flag_sets(config_raw.get('flagSetsFilter'), 'Telemetry Init'))
+
+    config = sanitize_config(api_key, config_raw)
 
     if config['operationMode'] == 'localhost':
         split_factory =  _build_localhost_factory(config)
@@ -700,7 +708,9 @@ def get_factory(api_key, **kwargs):
         kwargs.get('events_api_base_url'),
         kwargs.get('auth_api_base_url'),
         kwargs.get('streaming_api_base_url'),
-        kwargs.get('telemetry_api_base_url'))
+        kwargs.get('telemetry_api_base_url'),
+        total_flag_sets,
+        invalid_flag_sets)
 
     return split_factory
 
@@ -712,4 +722,4 @@ def _get_active_and_redundant_count():
         redundant_factory_count += _INSTANTIATED_FACTORIES[item] - 1
         active_factory_count += _INSTANTIATED_FACTORIES[item]
     _INSTANTIATED_FACTORIES_LOCK.release()
-    return redundant_factory_count, active_factory_count
+    return redundant_factory_count, active_factory_count

{splitio_client-9.5.1 → splitio_client-9.6.1}/splitio/client/input_validator.py

@@ -15,6 +15,7 @@ _LOGGER = logging.getLogger(__name__)
 MAX_LENGTH = 250
 EVENT_TYPE_PATTERN = r'^[a-zA-Z0-9][-_.:a-zA-Z0-9]{0,79}$'
 MAX_PROPERTIES_LENGTH_BYTES = 32768
+_FLAG_SETS_REGEX = '^[a-z0-9][_a-z0-9]{0,49}$'
 
 
 def _check_not_null(value, name, operation):
@@ -79,7 +80,8 @@ def _check_string_not_empty(value, name, operation):
     return True
 
 
-def _check_string_matches(value, operation, pattern):
+
+def _check_string_matches(value, operation, pattern, name, length):
     """
     Check if value is adhere to a regular expression passed.
 
@@ -92,14 +94,14 @@ def _check_string_matches(value, operation, pattern):
     :return: The result of validation
     :rtype: True|False
     """
-    if not re.match(pattern, value):
+    if re.search(pattern, value) is None or re.search(pattern, value).group() != value:
         _LOGGER.error(
             '%s: you passed %s, event_type must ' +
             'adhere to the regular expression %s. ' +
-            'This means an event name must be alphanumeric, cannot be more ' +
-            'than 80 characters long, and can only include a dash, underscore, ' +
+            'This means %s must be alphanumeric, cannot be more ' +
+            'than %s characters long, and can only include a dash, underscore, ' +
             'period, or colon as separators of alphanumeric characters.',
-            operation, value, pattern
+            operation, value, pattern, name, length
         )
         return False
     return True
@@ -165,10 +167,7 @@ def _check_valid_object_key(key, name, operation):
     :return: The result of validation
     :rtype: str|None
     """
-    if key is None:
-        _LOGGER.error(
-            '%s: you passed a null %s, %s must be a non-empty string.',
-            operation, name, name)
+    if not _check_not_null(key, 'key', operation):
         return None
     if isinstance(key, str):
         if not _check_string_not_empty(key, name, operation):
@@ -179,7 +178,7 @@ def _check_valid_object_key(key, name, operation):
     return key_str
 
 
-def _remove_empty_spaces(value, operation):
+def _remove_empty_spaces(value, name, operation):
     """
     Check if an string has whitespaces.
 
@@ -192,10 +191,17 @@ def _remove_empty_spaces(value, operation):
     """
     strip_value = value.strip()
     if value != strip_value:
-        _LOGGER.warning("%s: feature flag name '%s' has extra whitespace, trimming.", operation, value)
+        _LOGGER.warning("%s: %s '%s' has extra whitespace, trimming.", operation, name, value)
     return strip_value
 
 
+def _convert_str_to_lower(value, name, operation):
+    lower_value = value.lower()
+    if value != lower_value:
+        _LOGGER.warning("%s: %s '%s' should be all lowercase - converting string to lowercase" % (operation, name, value))
+    return lower_value
+
+
 def validate_key(key, method_name):
     """
     Validate Key parameter for get_treatment/s.
@@ -211,8 +217,7 @@ def validate_key(key, method_name):
     """
     matching_key_result = None
     bucketing_key_result = None
-    if key is None:
-        _LOGGER.error('%s: you passed a null key, key must be a non-empty string.', method_name)
+    if not _check_not_null(key, 'key', method_name):
         return None, None
 
     if isinstance(key, Key):
@@ -255,7 +260,7 @@ def validate_feature_flag_name(feature_flag_name, should_validate_existance, fea
         )
         return None
 
-    return _remove_empty_spaces(feature_flag_name, method_name)
+    return _remove_empty_spaces(feature_flag_name, 'feature flag name', method_name)
 
 
 def validate_track_key(key):
@@ -294,10 +299,7 @@ def validate_traffic_type(traffic_type, should_validate_existance, feature_flag_
        (not _check_is_string(traffic_type, 'traffic_type', 'track')) or \
        (not _check_string_not_empty(traffic_type, 'traffic_type', 'track')):
         return None
-    if not traffic_type.islower():
-        _LOGGER.warning('track: %s should be all lowercase - converting string to lowercase.',
-                        traffic_type)
-        traffic_type = traffic_type.lower()
+    traffic_type = _convert_str_to_lower(traffic_type, 'traffic type', 'track')
 
     if should_validate_existance and not feature_flag_storage.is_valid_traffic_type(traffic_type):
         _LOGGER.warning(
@@ -322,7 +324,7 @@ def validate_event_type(event_type):
     if (not _check_not_null(event_type, 'event_type', 'track')) or \
        (not _check_is_string(event_type, 'event_type', 'track')) or \
        (not _check_string_not_empty(event_type, 'event_type', 'track')) or \
-       (not _check_string_matches(event_type, 'track', EVENT_TYPE_PATTERN)):
+       (not _check_string_matches(event_type, 'track', EVENT_TYPE_PATTERN, 'an event name', 80)):
         return None
     return event_type
 
@@ -390,7 +392,7 @@ def validate_feature_flags_get_treatments(  # pylint: disable=invalid-name
         _LOGGER.error("%s: feature flag names must be a non-empty array.", method_name)
         return None, None
     filtered_feature_flags = set(
-        _remove_empty_spaces(feature_flag, method_name) for feature_flag in feature_flags
+        _remove_empty_spaces(feature_flag, 'feature flag name', method_name) for feature_flag in feature_flags
         if feature_flag is not None and
         _check_is_string(feature_flag, 'feature flag name', method_name) and
         _check_string_not_empty(feature_flag, 'feature flag name', method_name)
@@ -566,3 +568,33 @@ def validate_pluggable_adapter(config):
             _LOGGER.error("Pluggable adapter method %s has less than required arguments count: %s : " % (exp_method, len(get_method_args)))
             return False
     return True
+
+def validate_flag_sets(flag_sets, method_name):
+    """
+    Validate flag sets list
+
+    :param flag_set: list of flag sets
+    :type flag_set: list[str]
+
+    :returns: Sanitized and sorted flag sets
+    :rtype: list[str]
+    """
+    if not isinstance(flag_sets, list):
+        _LOGGER.warning("%s: flag sets parameter type should be list object, parameter is discarded" % (method_name))
+        return []
+
+    sanitized_flag_sets = set()
+    for flag_set in flag_sets:
+        if not _check_not_null(flag_set, 'flag set', method_name):
+            continue
+        if not _check_is_string(flag_set, 'flag set', method_name):
+            continue
+        flag_set = _remove_empty_spaces(flag_set, 'flag set', method_name)
+        flag_set = _convert_str_to_lower(flag_set, 'flag set', method_name)
+
+        if not _check_string_matches(flag_set, method_name, _FLAG_SETS_REGEX, 'a flag set', 50):
+            continue
+
+        sanitized_flag_sets.add(flag_set)
+
+    return list(sanitized_flag_sets)

{splitio_client-9.5.1 → splitio_client-9.6.1}/splitio/engine/telemetry.py

@@ -36,9 +36,9 @@ class TelemetryInitProducer(object):
         """Constructor."""
         self._telemetry_storage = telemetry_storage
 
-    def record_config(self, config, extra_config):
+    def record_config(self, config, extra_config, total_flag_sets=0, invalid_flag_sets=0):
         """Record configurations."""
-        self._telemetry_storage.record_config(config, extra_config)
+        self._telemetry_storage.record_config(config, extra_config, total_flag_sets, invalid_flag_sets)
         current_app, app_worker_id = self._get_app_worker_id()
         if  current_app is not None:
             self.add_config_tag("initilization:" + current_app)
@@ -48,6 +48,14 @@ class TelemetryInitProducer(object):
         """Record ready time."""
         self._telemetry_storage.record_ready_time(ready_time)
 
+    def record_flag_sets(self, flag_sets):
+        """Record flag sets."""
+        self._telemetry_storage.record_flag_sets(flag_sets)
+
+    def record_invalid_flag_sets(self, flag_sets):
+        """Record invalid flag sets."""
+        self._telemetry_storage.record_invalid_flag_sets(flag_sets)
+
     def record_bur_time_out(self):
         """Record block until ready timeout."""
         self._telemetry_storage.record_bur_time_out()
@@ -218,17 +226,27 @@ class TelemetryEvaluationConsumer(object):
         exceptions = self.pop_exceptions()['methodExceptions']
         latencies = self.pop_latencies()['methodLatencies']
         return {
-            'mE': {'t': exceptions['treatment'],
-                      'ts': exceptions['treatments'],
-                      'tc': exceptions['treatment_with_config'],
-                      'tcs': exceptions['treatments_with_config'],
-                      'tr': exceptions['track']
+            'mE': {
+                't': exceptions['treatment'],
+                'ts': exceptions['treatments'],
+                'tc': exceptions['treatment_with_config'],
+                'tcs': exceptions['treatments_with_config'],
+                'tf': exceptions['treatments_by_flag_set'],
+                'tfs': exceptions['treatments_by_flag_sets'],
+                'tcf': exceptions['treatments_with_config_by_flag_set'],
+                'tcfs': exceptions['treatments_with_config_by_flag_sets'],
+                'tr': exceptions['track']
                },
-            'mL':  {'t': latencies['treatment'],
-                      'ts': latencies['treatments'],
-                      'tc': latencies['treatment_with_config'],
-                      'tcs': latencies['treatments_with_config'],
-                      'tr': latencies['track']
+            'mL':  {
+                't': latencies['treatment'],
+                'ts': latencies['treatments'],
+                'tc': latencies['treatment_with_config'],
+                'tcs': latencies['treatments_with_config'],
+                'tf': latencies['treatments_by_flag_set'],
+                'tfs': latencies['treatments_by_flag_sets'],
+                'tcf': latencies['treatments_with_config_by_flag_set'],
+                'tcfs': latencies['treatments_with_config_by_flag_sets'],
+                'tr': latencies['track']
                },
         }