splitio-client 10.2.0__tar.gz → 10.3.0__tar.gz

splitio_client-10.3.0/PKG-INFO

@@ -0,0 +1,101 @@
+Metadata-Version: 2.1
+Name: splitio_client
+Version: 10.3.0
+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/10.3.0
+Description: # Split Python SDK
+        ![Build Status](https://github.com/splitio/python-client/actions/workflows/ci.yml/badge.svg?branch=master)
+        
+        ## Overview
+        This SDK is designed to work with Split, the platform for controlled rollouts, which serves features to your users via a Split feature flag to manage your complete customer experience.
+        
+        [![Twitter Follow](https://img.shields.io/twitter/follow/splitsoftware.svg?style=social&label=Follow&maxAge=1529000)](https://twitter.com/intent/follow?screen_name=splitsoftware)
+        
+        ## Compatibility
+        This SDK is compatible with **Python 3.7 and higher**.
+        
+        ## Getting started
+        Below is a simple example that describes the instantiation and most basic usage of our SDK:
+        
+        Run `pip install splitio_client`
+        
+        
+        ```python
+        from splitio import get_factory
+        from splitio.exceptions import TimeoutException
+        factory = get_factory('YOUR_SDK_TYPE_API_KEY', config=config)
+        try:
+            factory.block_until_ready(5) # wait up to 5 seconds
+            split = factory.client()
+            treatment = split.get_treatment('CUSTOMER_ID', 'FEATURE_FLAG_NAME')
+            if treatment == "on":
+                # insert code here to show on treatment
+            elif treatment == "off":
+                # insert code here to show off treatment
+            else:
+                # insert your control treatment code here
+        except TimeoutException:
+            # Now the user can choose whether to abort the whole execution, or just keep going
+            # without a ready client, which if configured properly, should become ready at some point.
+            pass
+        ```
+        
+        Please refer to [our official docs](https://help.split.io/hc/en-us/articles/360020359652-Python-SDK) to learn about all the functionality provided by our SDK and the configuration options available for tailoring it to your current application setup.
+        
+        ## Submitting issues
+        The Split team monitors all issues submitted to this [issue tracker](https://github.com/splitio/python-client/issues). We encourage you to use this issue tracker to submit any bug reports, feedback, and feature enhancements. We'll do our best to respond in a timely manner.
+        
+        ## Contributing
+        Please see [Contributors Guide](CONTRIBUTORS-GUIDE.md) to find all you need to submit a Pull Request (PR).
+        
+        ## License
+        Licensed under the Apache License, Version 2.0. See: [Apache License](http://www.apache.org/licenses/).
+        
+        ## About Split
+        
+        Split is the leading Feature Delivery Platform for engineering teams that want to confidently deploy features as fast as they can develop them. Split’s fine-grained management, real-time monitoring, and data-driven experimentation ensure that new features will improve the customer experience without breaking or degrading performance. Companies like Twilio, Salesforce, GoDaddy and WePay trust Split to power their feature delivery.
+        
+        To learn more about Split, contact hello@split.io, or get started with feature flags for free at https://www.split.io/signup.
+        
+        Split has built and maintains SDKs for:
+        
+        * .NET [Github](https://github.com/splitio/dotnet-client) [Docs](https://help.split.io/hc/en-us/articles/360020240172--NET-SDK)
+        * Android [Github](https://github.com/splitio/android-client) [Docs](https://help.split.io/hc/en-us/articles/360020343291-Android-SDK)
+        * Angular [Github](https://github.com/splitio/angular-sdk-plugin) [Docs](https://help.split.io/hc/en-us/articles/6495326064397-Angular-utilities)
+        * GO [Github](https://github.com/splitio/go-client) [Docs](https://help.split.io/hc/en-us/articles/360020093652-Go-SDK)
+        * iOS [Github](https://github.com/splitio/ios-client) [Docs](https://help.split.io/hc/en-us/articles/360020401491-iOS-SDK)
+        * Java [Github](https://github.com/splitio/java-client) [Docs](https://help.split.io/hc/en-us/articles/360020405151-Java-SDK)
+        * JavaScript [Github](https://github.com/splitio/javascript-client) [Docs](https://help.split.io/hc/en-us/articles/360020448791-JavaScript-SDK)
+        * JavaScript for Browser [Github](https://github.com/splitio/javascript-browser-client) [Docs](https://help.split.io/hc/en-us/articles/360058730852-Browser-SDK)
+        * Node [Github](https://github.com/splitio/javascript-client) [Docs](https://help.split.io/hc/en-us/articles/360020564931-Node-js-SDK)
+        * PHP [Github](https://github.com/splitio/php-client) [Docs](https://help.split.io/hc/en-us/articles/360020350372-PHP-SDK)
+        * Python [Github](https://github.com/splitio/python-client) [Docs](https://help.split.io/hc/en-us/articles/360020359652-Python-SDK)
+        * React [Github](https://github.com/splitio/react-client) [Docs](https://help.split.io/hc/en-us/articles/360038825091-React-SDK)
+        * React Native [Github](https://github.com/splitio/react-native-client) [Docs](https://help.split.io/hc/en-us/articles/4406066357901-React-Native-SDK)
+        * Redux [Github](https://github.com/splitio/redux-client) [Docs](https://help.split.io/hc/en-us/articles/360038851551-Redux-SDK)
+        * Ruby [Github](https://github.com/splitio/ruby-client) [Docs](https://help.split.io/hc/en-us/articles/360020673251-Ruby-SDK)
+        
+        For a comprehensive list of open source projects visit our [Github page](https://github.com/splitio?utf8=%E2%9C%93&query=%20only%3Apublic%20).
+        
+        **Learn more about Split:**
+        
+        Visit [split.io/product](https://www.split.io/product) for an overview of Split, or visit our documentation at [help.split.io](http://help.split.io) for more detailed information.
+        
+Platform: UNKNOWN
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 2
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Software Development :: Libraries
+Description-Content-Type: text/markdown
+Provides-Extra: test
+Provides-Extra: redis
+Provides-Extra: uwsgi
+Provides-Extra: cpphash
+Provides-Extra: asyncio
+Provides-Extra: kerberos

{splitio_client-10.2.0 → splitio_client-10.3.0}/setup.py

@@ -8,7 +8,7 @@ TESTS_REQUIRES = [
     'flake8',
     'pytest==7.0.1',
     'pytest-mock==3.11.1',
-    'coverage',
+    'coverage==7.0.0',
     'pytest-cov==4.1.0',
     'importlib-metadata==6.7',
     'tomli==1.2.3',
@@ -17,7 +17,8 @@ TESTS_REQUIRES = [
     'pytest-asyncio==0.21.0',
     'aiohttp>=3.8.4',
     'aiofiles>=23.1.0',
-    'requests-kerberos>=0.15.0'
+    'requests-kerberos>=0.15.0',
+    'urllib3==2.0.7'
 ]
 
 INSTALL_REQUIRES = [

{splitio_client-10.2.0 → splitio_client-10.3.0}/splitio/api/client.py

@@ -92,6 +92,25 @@ class HTTPAdapterWithProxyKerberosAuth(requests.adapters.HTTPAdapter):
 class HttpClientBase(object, metaclass=abc.ABCMeta):
     """HttpClient wrapper template."""
 
+    def __init__(self, timeout=None, sdk_url=None, events_url=None, auth_url=None, telemetry_url=None):
+        """
+        Class constructor.
+
+        :param timeout: How many milliseconds to wait until the server responds.
+        :type timeout: int
+        :param sdk_url: Optional alternative sdk URL.
+        :type sdk_url: str
+        :param events_url: Optional alternative events URL.
+        :type events_url: str
+        :param auth_url: Optional alternative auth URL.
+        :type auth_url: str
+        :param telemetry_url: Optional alternative telemetry URL.
+        :type telemetry_url: str
+        """
+        _LOGGER.debug("Initializing httpclient")
+        self._timeout = timeout/1000 if timeout else None # Convert ms to seconds.
+        self._urls = _construct_urls(sdk_url, events_url, auth_url, telemetry_url)
+
     @abc.abstractmethod
     def get(self, server, path, apikey):
         """http get request"""
@@ -113,6 +132,9 @@ class HttpClientBase(object, metaclass=abc.ABCMeta):
         self._telemetry_runtime_producer = telemetry_runtime_producer
         self._metric_name = metric_name
 
+    def is_sdk_endpoint_overridden(self):
+        return self._urls['sdk'] != SDK_URL
+
     def _get_headers(self, extra_headers, sdk_key):
         headers = _build_basic_headers(sdk_key)
         if extra_headers is not None:
@@ -154,10 +176,8 @@ class HttpClient(HttpClientBase):
         :param telemetry_url: Optional alternative telemetry URL.
         :type telemetry_url: str
         """
-        _LOGGER.debug("Initializing httpclient")
-        self._timeout = timeout/1000 if timeout else None # Convert ms to seconds.
-        self._urls = _construct_urls(sdk_url, events_url, auth_url, telemetry_url)
-
+        HttpClientBase.__init__(self, timeout, sdk_url, events_url, auth_url, telemetry_url)
+        
     def get(self, server, path, sdk_key, query=None, extra_headers=None):  # pylint: disable=too-many-arguments
         """
         Issue a get request.
@@ -187,7 +207,11 @@ class HttpClient(HttpClientBase):
             self._record_telemetry(response.status_code, get_current_epoch_time_ms() - start)
             return HttpResponse(response.status_code, response.text, response.headers)
 
-        except Exception as exc:  # pylint: disable=broad-except
+        except requests.exceptions.ChunkedEncodingError as exc:
+            _LOGGER.error("IncompleteRead exception detected: %s", exc)
+            return HttpResponse(400, "", {})      
+            
+        except Exception as exc:  # pylint: disable=broad-except            
             raise HttpClientException(_EXC_MSG.format(source='request')) from exc
 
     def post(self, server, path, sdk_key, body, query=None, extra_headers=None):  # pylint: disable=too-many-arguments
@@ -241,8 +265,7 @@ class HttpClientAsync(HttpClientBase):
         :param telemetry_url: Optional alternative telemetry URL.
         :type telemetry_url: str
         """
-        self._timeout = timeout/1000 if timeout else None  # Convert ms to seconds.
-        self._urls = _construct_urls(sdk_url, events_url, auth_url, telemetry_url)
+        HttpClientBase.__init__(self, timeout, sdk_url, events_url, auth_url, telemetry_url)
         self._session = aiohttp.ClientSession()
 
     async def get(self, server, path, apikey, query=None, extra_headers=None):  # pylint: disable=too-many-arguments
@@ -281,6 +304,10 @@ class HttpClientAsync(HttpClientBase):
                 await self._record_telemetry(response.status, get_current_epoch_time_ms() - start)
                 return HttpResponse(response.status, body, response.headers)
 
+        except aiohttp.ClientPayloadError as exc:
+                _LOGGER.error("ContentLengthError exception detected: %s", exc)
+                return HttpResponse(400, "", {})      
+            
         except aiohttp.ClientError as exc:  # pylint: disable=broad-except
             raise HttpClientException(_EXC_MSG.format(source='aiohttp')) from exc
 

{splitio_client-10.2.0 → splitio_client-10.3.0}/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, sets=None, spec=SPEC_VERSION):
+    def __init__(self, cache_control_headers=False, change_number=None, rbs_change_number=None, sets=None, spec=SPEC_VERSION):
         """
         Class constructor.
 
@@ -72,6 +72,7 @@ class FetchOptions(object):
         """
         self._cache_control_headers = cache_control_headers
         self._change_number = change_number
+        self._rbs_change_number = rbs_change_number
         self._sets = sets
         self._spec = spec
 
@@ -85,6 +86,11 @@ class FetchOptions(object):
         """Return change number."""
         return self._change_number
 
+    @property
+    def rbs_change_number(self):
+        """Return change number."""
+        return self._rbs_change_number
+
     @property
     def sets(self):
         """Return sets."""
@@ -103,14 +109,19 @@ class FetchOptions(object):
         if self._change_number != other._change_number:
             return False
 
+        if self._rbs_change_number != other._rbs_change_number:
+            return False
+
         if self._sets != other._sets:
             return False
+        
         if self._spec != other._spec:
             return False
+        
         return True
 
 
-def build_fetch(change_number, fetch_options, metadata):
+def build_fetch(change_number, fetch_options, metadata, rbs_change_number=None):
     """
     Build fetch with new flags if that is the case.
 
@@ -123,11 +134,16 @@ def build_fetch(change_number, fetch_options, metadata):
     :param metadata: Metadata Headers.
     :type metadata: dict
 
+    :param rbs_change_number: Last known timestamp of a rule based segment modification.
+    :type rbs_change_number: int
+
     :return: Objects for fetch
     :rtype: dict, dict
     """
     query = {'s': fetch_options.spec} if fetch_options.spec is not None else {}
     query['since'] = change_number
+    if rbs_change_number is not None:
+        query['rbSince'] = rbs_change_number
     extra_headers = metadata
     if fetch_options is None:
         return query, extra_headers

splitio_client-10.3.0/splitio/api/splits.py

@@ -0,0 +1,202 @@
+"""Splits API module."""
+
+import logging
+import json
+
+from splitio.api import APIException, headers_from_metadata
+from splitio.api.commons import build_fetch, FetchOptions
+from splitio.api.client import HttpClientException
+from splitio.models.telemetry import HTTPExceptionsAndLatencies
+from splitio.util.time import utctime_ms
+from splitio.spec import SPEC_VERSION
+from splitio.sync import util
+
+_LOGGER = logging.getLogger(__name__)
+_SPEC_1_1 = "1.1"
+_PROXY_CHECK_INTERVAL_MILLISECONDS_SS =  24 * 60 * 60 * 1000
+
+class SplitsAPIBase(object):  # pylint: disable=too-few-public-methods
+    """Class that uses an httpClient to communicate with the splits API."""
+
+    def __init__(self, client, sdk_key, sdk_metadata, telemetry_runtime_producer):
+        """
+        Class constructor.
+
+        :param client: HTTP Client responsble for issuing calls to the backend.
+        :type client: HttpClient
+        :param sdk_key: User sdk_key token.
+        :type sdk_key: string
+        :param sdk_metadata: SDK version & machine name & IP.
+        :type sdk_metadata: splitio.client.util.SdkMetadata
+        """
+        self._client = client
+        self._sdk_key = sdk_key
+        self._metadata = headers_from_metadata(sdk_metadata)
+        self._telemetry_runtime_producer = telemetry_runtime_producer
+        self._client.set_telemetry_data(HTTPExceptionsAndLatencies.SPLIT, self._telemetry_runtime_producer)
+        self._spec_version = SPEC_VERSION
+        self._last_proxy_check_timestamp = 0
+        self.clear_storage = False
+        self._old_spec_since = None
+
+    def _check_last_proxy_check_timestamp(self, since):
+        if self._spec_version == _SPEC_1_1 and ((utctime_ms() - self._last_proxy_check_timestamp) >= _PROXY_CHECK_INTERVAL_MILLISECONDS_SS):
+            _LOGGER.info("Switching to new Feature flag spec (%s) and fetching.", SPEC_VERSION);
+            self._spec_version = SPEC_VERSION
+            self._old_spec_since = since
+    
+    def _check_old_spec_since(self, change_number):
+        if self._spec_version == _SPEC_1_1 and self._old_spec_since is not None:
+            since = self._old_spec_since
+            self._old_spec_since = None
+            return since
+        return change_number
+    
+
+class SplitsAPI(SplitsAPIBase):  # pylint: disable=too-few-public-methods
+    """Class that uses an httpClient to communicate with the splits API."""
+
+    def __init__(self, client, sdk_key, sdk_metadata, telemetry_runtime_producer):
+        """
+        Class constructor.
+
+        :param client: HTTP Client responsble for issuing calls to the backend.
+        :type client: HttpClient
+        :param sdk_key: User sdk_key token.
+        :type sdk_key: string
+        :param sdk_metadata: SDK version & machine name & IP.
+        :type sdk_metadata: splitio.client.util.SdkMetadata
+        """
+        SplitsAPIBase.__init__(self, client, sdk_key, sdk_metadata, telemetry_runtime_producer)
+
+    def fetch_splits(self, change_number, rbs_change_number, fetch_options):
+        """
+        Fetch feature flags from backend.
+
+        :param change_number: Last known timestamp of a split modification.
+        :type change_number: int
+
+        :param rbs_change_number: Last known timestamp of a rule based segment modification.
+        :type rbs_change_number: int
+
+        :param fetch_options: Fetch options for getting feature flag definitions.
+        :type fetch_options: splitio.api.commons.FetchOptions
+
+        :return: Json representation of a splitChanges response.
+        :rtype: dict
+        """
+        try:
+            self._check_last_proxy_check_timestamp(change_number)
+            change_number = self._check_old_spec_since(change_number)
+
+            if self._spec_version == _SPEC_1_1:
+                fetch_options = FetchOptions(fetch_options.cache_control_headers, fetch_options.change_number,
+                                                                               None, fetch_options.sets, self._spec_version)
+                rbs_change_number = None
+            query, extra_headers = build_fetch(change_number, fetch_options, self._metadata, rbs_change_number)
+            response = self._client.get(
+                'sdk',
+                'splitChanges',
+                self._sdk_key,
+                extra_headers=extra_headers,
+                query=query,
+            )
+            if 200 <= response.status_code < 300:
+                if self._spec_version == _SPEC_1_1:
+                    return util.convert_to_new_spec(json.loads(response.body))
+                
+                self.clear_storage = self._last_proxy_check_timestamp != 0
+                self._last_proxy_check_timestamp = 0
+                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.')
+                    
+                if self._client.is_sdk_endpoint_overridden() and response.status_code == 400 and self._spec_version == SPEC_VERSION:
+                    _LOGGER.warning('Detected proxy response error, changing spec version from %s to %s and re-fetching.', self._spec_version, _SPEC_1_1)
+                    self._spec_version = _SPEC_1_1
+                    self._last_proxy_check_timestamp = utctime_ms()                    
+                    return self.fetch_splits(change_number, None, FetchOptions(fetch_options.cache_control_headers, fetch_options.change_number,
+                                                                               None, fetch_options.sets, self._spec_version))
+                    
+                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')
+            _LOGGER.debug('Error: ', exc_info=True)
+            raise APIException('Feature flags not fetched correctly.') from exc
+
+class SplitsAPIAsync(SplitsAPIBase):  # pylint: disable=too-few-public-methods
+    """Class that uses an httpClient to communicate with the splits API."""
+
+    def __init__(self, client, sdk_key, sdk_metadata, telemetry_runtime_producer):
+        """
+        Class constructor.
+
+        :param client: HTTP Client responsble for issuing calls to the backend.
+        :type client: HttpClient
+        :param sdk_key: User sdk_key token.
+        :type sdk_key: string
+        :param sdk_metadata: SDK version & machine name & IP.
+        :type sdk_metadata: splitio.client.util.SdkMetadata
+        """
+        SplitsAPIBase.__init__(self, client, sdk_key, sdk_metadata, telemetry_runtime_producer)
+
+    async def fetch_splits(self, change_number, rbs_change_number, fetch_options):
+        """
+        Fetch feature flags from backend.
+
+        :param change_number: Last known timestamp of a split modification.
+        :type change_number: int
+        
+        :param rbs_change_number: Last known timestamp of a rule based segment modification.
+        :type rbs_change_number: int
+
+        :param fetch_options: Fetch options for getting feature flag definitions.
+        :type fetch_options: splitio.api.commons.FetchOptions
+
+        :return: Json representation of a splitChanges response.
+        :rtype: dict
+        """
+        try:
+            self._check_last_proxy_check_timestamp(change_number)
+            change_number = self._check_old_spec_since(change_number)
+            if self._spec_version == _SPEC_1_1:
+                fetch_options = FetchOptions(fetch_options.cache_control_headers, fetch_options.change_number,
+                                                                               None, fetch_options.sets, self._spec_version)
+                rbs_change_number = None
+            
+            query, extra_headers = build_fetch(change_number, fetch_options, self._metadata, rbs_change_number)
+            response = await self._client.get(
+                'sdk',
+                'splitChanges',
+                self._sdk_key,
+                extra_headers=extra_headers,
+                query=query,
+            )
+            if 200 <= response.status_code < 300:
+                if self._spec_version == _SPEC_1_1:
+                    return util.convert_to_new_spec(json.loads(response.body))
+                
+                self.clear_storage = self._last_proxy_check_timestamp != 0
+                self._last_proxy_check_timestamp = 0
+                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.')
+                    
+                if self._client.is_sdk_endpoint_overridden() and response.status_code == 400 and self._spec_version == SPEC_VERSION:
+                    _LOGGER.warning('Detected proxy response error, changing spec version from %s to %s and re-fetching.', self._spec_version, _SPEC_1_1)
+                    self._spec_version = _SPEC_1_1
+                    self._last_proxy_check_timestamp = utctime_ms()                    
+                    return await self.fetch_splits(change_number, None, FetchOptions(fetch_options.cache_control_headers, fetch_options.change_number,
+                                                                               None, fetch_options.sets, self._spec_version))
+
+                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')
+            _LOGGER.debug('Error: ', exc_info=True)
+            raise APIException('Feature flags not fetched correctly.') from exc

{splitio_client-10.2.0 → splitio_client-10.3.0}/splitio/client/client.py

@@ -201,7 +201,7 @@ class Client(ClientBase):  # pylint: disable=too-many-instance-attributes
         :rtype: Client
         """
         ClientBase.__init__(self, factory, recorder, labels_enabled)
-        self._context_factory = EvaluationDataFactory(factory._get_storage('splits'), factory._get_storage('segments'))
+        self._context_factory = EvaluationDataFactory(factory._get_storage('splits'), factory._get_storage('segments'), factory._get_storage('rule_based_segments'))
 
     def destroy(self):
         """
@@ -668,7 +668,7 @@ class ClientAsync(ClientBase):  # pylint: disable=too-many-instance-attributes
         :rtype: Client
         """
         ClientBase.__init__(self, factory, recorder, labels_enabled)
-        self._context_factory = AsyncEvaluationDataFactory(factory._get_storage('splits'), factory._get_storage('segments'))
+        self._context_factory = AsyncEvaluationDataFactory(factory._get_storage('splits'), factory._get_storage('segments'), factory._get_storage('rule_based_segments'))
 
     async def destroy(self):
         """

{splitio_client-10.2.0 → splitio_client-10.3.0}/splitio/client/factory.py

@@ -23,14 +23,17 @@ from splitio.engine.impressions.unique_keys_tracker import UniqueKeysTracker, Un
 from splitio.storage.inmemmory import InMemorySplitStorage, InMemorySegmentStorage, \
     InMemoryImpressionStorage, InMemoryEventStorage, InMemoryTelemetryStorage, LocalhostTelemetryStorage, \
     InMemorySplitStorageAsync, InMemorySegmentStorageAsync, InMemoryImpressionStorageAsync, \
-    InMemoryEventStorageAsync, InMemoryTelemetryStorageAsync, LocalhostTelemetryStorageAsync
+    InMemoryEventStorageAsync, InMemoryTelemetryStorageAsync, LocalhostTelemetryStorageAsync, \
+    InMemoryRuleBasedSegmentStorage, InMemoryRuleBasedSegmentStorageAsync
 from splitio.storage.adapters import redis
 from splitio.storage.redis import RedisSplitStorage, RedisSegmentStorage, RedisImpressionsStorage, \
     RedisEventsStorage, RedisTelemetryStorage, RedisSplitStorageAsync, RedisEventsStorageAsync,\
-    RedisSegmentStorageAsync, RedisImpressionsStorageAsync, RedisTelemetryStorageAsync
+    RedisSegmentStorageAsync, RedisImpressionsStorageAsync, RedisTelemetryStorageAsync, \
+    RedisRuleBasedSegmentsStorage, RedisRuleBasedSegmentsStorageAsync
 from splitio.storage.pluggable import PluggableEventsStorage, PluggableImpressionsStorage, PluggableSegmentStorage, \
     PluggableSplitStorage, PluggableTelemetryStorage, PluggableTelemetryStorageAsync, PluggableEventsStorageAsync, \
-    PluggableImpressionsStorageAsync, PluggableSegmentStorageAsync, PluggableSplitStorageAsync
+    PluggableImpressionsStorageAsync, PluggableSegmentStorageAsync, PluggableSplitStorageAsync, \
+    PluggableRuleBasedSegmentsStorage, PluggableRuleBasedSegmentsStorageAsync
 
 # APIs
 from splitio.api.client import HttpClient, HttpClientAsync, HttpClientKerberos
@@ -543,6 +546,7 @@ def _build_in_memory_factory(api_key, cfg, sdk_url=None, events_url=None,  # pyl
     storages = {
         'splits': InMemorySplitStorage(cfg['flagSetsFilter'] if cfg['flagSetsFilter'] is not None else []),
         'segments': InMemorySegmentStorage(),
+        'rule_based_segments': InMemoryRuleBasedSegmentStorage(),
         'impressions': InMemoryImpressionStorage(cfg['impressionsQueueSize'], telemetry_runtime_producer),
         'events': InMemoryEventStorage(cfg['eventsQueueSize'], telemetry_runtime_producer),
     }
@@ -559,8 +563,8 @@ def _build_in_memory_factory(api_key, cfg, sdk_url=None, events_url=None,  # pyl
         imp_strategy, none_strategy, telemetry_runtime_producer)
 
     synchronizers = SplitSynchronizers(
-        SplitSynchronizer(apis['splits'], storages['splits']),
-        SegmentSynchronizer(apis['segments'], storages['splits'], storages['segments']),
+        SplitSynchronizer(apis['splits'], storages['splits'], storages['rule_based_segments']),
+        SegmentSynchronizer(apis['segments'], storages['splits'], storages['segments'], storages['rule_based_segments']),
         ImpressionSynchronizer(apis['impressions'], storages['impressions'],
                                cfg['impressionsBulkSize']),
         EventSynchronizer(apis['events'], storages['events'], cfg['eventsBulkSize']),
@@ -671,6 +675,7 @@ async def _build_in_memory_factory_async(api_key, cfg, sdk_url=None, events_url=
     storages = {
         'splits': InMemorySplitStorageAsync(cfg['flagSetsFilter'] if cfg['flagSetsFilter'] is not None else []),
         'segments': InMemorySegmentStorageAsync(),
+        'rule_based_segments': InMemoryRuleBasedSegmentStorageAsync(),
         'impressions': InMemoryImpressionStorageAsync(cfg['impressionsQueueSize'], telemetry_runtime_producer),
         'events': InMemoryEventStorageAsync(cfg['eventsQueueSize'], telemetry_runtime_producer),
     }
@@ -687,8 +692,8 @@ async def _build_in_memory_factory_async(api_key, cfg, sdk_url=None, events_url=
         imp_strategy, none_strategy, telemetry_runtime_producer)
 
     synchronizers = SplitSynchronizers(
-        SplitSynchronizerAsync(apis['splits'], storages['splits']),
-        SegmentSynchronizerAsync(apis['segments'], storages['splits'], storages['segments']),
+        SplitSynchronizerAsync(apis['splits'], storages['splits'], storages['rule_based_segments']),
+        SegmentSynchronizerAsync(apis['segments'], storages['splits'], storages['segments'], storages['rule_based_segments']),
         ImpressionSynchronizerAsync(apis['impressions'], storages['impressions'],
                                cfg['impressionsBulkSize']),
         EventSynchronizerAsync(apis['events'], storages['events'], cfg['eventsBulkSize']),
@@ -756,6 +761,7 @@ def _build_redis_factory(api_key, cfg):
     storages = {
         'splits': RedisSplitStorage(redis_adapter, cache_enabled, cache_ttl, []),
         'segments': RedisSegmentStorage(redis_adapter),
+        'rule_based_segments': RedisRuleBasedSegmentsStorage(redis_adapter),        
         'impressions': RedisImpressionsStorage(redis_adapter, sdk_metadata),
         'events': RedisEventsStorage(redis_adapter, sdk_metadata),
         'telemetry': RedisTelemetryStorage(redis_adapter, sdk_metadata)
@@ -839,6 +845,7 @@ async def _build_redis_factory_async(api_key, cfg):
     storages = {
         'splits': RedisSplitStorageAsync(redis_adapter, cache_enabled, cache_ttl),
         'segments': RedisSegmentStorageAsync(redis_adapter),
+        'rule_based_segments': RedisRuleBasedSegmentsStorageAsync(redis_adapter),        
         'impressions': RedisImpressionsStorageAsync(redis_adapter, sdk_metadata),
         'events': RedisEventsStorageAsync(redis_adapter, sdk_metadata),
         'telemetry': await RedisTelemetryStorageAsync.create(redis_adapter, sdk_metadata)
@@ -922,6 +929,7 @@ def _build_pluggable_factory(api_key, cfg):
     storages = {
         'splits': PluggableSplitStorage(pluggable_adapter, storage_prefix, []),
         'segments': PluggableSegmentStorage(pluggable_adapter, storage_prefix),
+        'rule_based_segments': PluggableRuleBasedSegmentsStorage(pluggable_adapter, storage_prefix),                
         'impressions': PluggableImpressionsStorage(pluggable_adapter, sdk_metadata, storage_prefix),
         'events': PluggableEventsStorage(pluggable_adapter, sdk_metadata, storage_prefix),
         'telemetry': PluggableTelemetryStorage(pluggable_adapter, sdk_metadata, storage_prefix)
@@ -1003,6 +1011,7 @@ async def _build_pluggable_factory_async(api_key, cfg):
     storages = {
         'splits': PluggableSplitStorageAsync(pluggable_adapter, storage_prefix),
         'segments': PluggableSegmentStorageAsync(pluggable_adapter, storage_prefix),
+        'rule_based_segments': PluggableRuleBasedSegmentsStorageAsync(pluggable_adapter, storage_prefix),   
         'impressions': PluggableImpressionsStorageAsync(pluggable_adapter, sdk_metadata, storage_prefix),
         'events': PluggableEventsStorageAsync(pluggable_adapter, sdk_metadata, storage_prefix),
         'telemetry': await PluggableTelemetryStorageAsync.create(pluggable_adapter, sdk_metadata, storage_prefix)
@@ -1081,6 +1090,7 @@ def _build_localhost_factory(cfg):
     storages = {
         'splits': InMemorySplitStorage(cfg['flagSetsFilter'] if cfg['flagSetsFilter'] is not None else []),
         'segments': InMemorySegmentStorage(),  # not used, just to avoid possible future errors.
+        'rule_based_segments': InMemoryRuleBasedSegmentStorage(),   
         'impressions': LocalhostImpressionsStorage(),
         'events': LocalhostEventsStorage(),
     }
@@ -1088,6 +1098,7 @@ def _build_localhost_factory(cfg):
     synchronizers = SplitSynchronizers(
         LocalSplitSynchronizer(cfg['splitFile'],
                                storages['splits'],
+                               storages['rule_based_segments'],
                                localhost_mode),
         LocalSegmentSynchronizer(cfg['segmentDirectory'], storages['splits'], storages['segments']),
         None, None, None,
@@ -1151,6 +1162,7 @@ async def _build_localhost_factory_async(cfg):
     storages = {
         'splits': InMemorySplitStorageAsync(),
         'segments': InMemorySegmentStorageAsync(),  # not used, just to avoid possible future errors.
+        'rule_based_segments': InMemoryRuleBasedSegmentStorageAsync(),
         'impressions': LocalhostImpressionsStorageAsync(),
         'events': LocalhostEventsStorageAsync(),
     }
@@ -1158,6 +1170,7 @@ async def _build_localhost_factory_async(cfg):
     synchronizers = SplitSynchronizers(
         LocalSplitSynchronizerAsync(cfg['splitFile'],
                                storages['splits'],
+                               storages['rule_based_segments'],
                                localhost_mode),
         LocalSegmentSynchronizerAsync(cfg['segmentDirectory'], storages['splits'], storages['segments']),
         None, None, None,