splitio-client 10.1.0rc2__tar.gz → 10.2.0__tar.gz

splitio_client-10.2.0/LICENSE.txt

@@ -0,0 +1,13 @@
+Copyright © 2025 Split Software, Inc.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

splitio_client-10.2.0/PKG-INFO

@@ -0,0 +1,125 @@
+Metadata-Version: 2.1
+Name: splitio_client
+Version: 10.2.0
+Summary: Split.io Python Client
+Home-page: https://github.com/splitio/python-client
+Download-URL: https://github.com/splitio/python-client/tarball/10.2.0
+Author: Patricio Echague, Sebastian Arrubia
+Author-email: pato@split.io, sebastian@split.io
+License: Apache License 2.0
+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
+License-File: LICENSE.txt
+Requires-Dist: requests
+Requires-Dist: pyyaml
+Requires-Dist: docopt>=0.6.2
+Requires-Dist: enum34; python_version < "3.4"
+Requires-Dist: bloom-filter2>=2.0.0
+Provides-Extra: test
+Requires-Dist: flake8; extra == "test"
+Requires-Dist: pytest==7.0.1; extra == "test"
+Requires-Dist: pytest-mock==3.11.1; extra == "test"
+Requires-Dist: coverage; extra == "test"
+Requires-Dist: pytest-cov==4.1.0; extra == "test"
+Requires-Dist: importlib-metadata==6.7; extra == "test"
+Requires-Dist: tomli==1.2.3; extra == "test"
+Requires-Dist: iniconfig==1.1.1; extra == "test"
+Requires-Dist: attrs==22.1.0; extra == "test"
+Requires-Dist: pytest-asyncio==0.21.0; extra == "test"
+Requires-Dist: aiohttp>=3.8.4; extra == "test"
+Requires-Dist: aiofiles>=23.1.0; extra == "test"
+Requires-Dist: requests-kerberos>=0.15.0; extra == "test"
+Provides-Extra: redis
+Requires-Dist: redis>=2.10.5; extra == "redis"
+Provides-Extra: uwsgi
+Requires-Dist: uwsgi>=2.0.0; extra == "uwsgi"
+Provides-Extra: cpphash
+Requires-Dist: mmh3cffi==0.2.1; extra == "cpphash"
+Provides-Extra: asyncio
+Requires-Dist: aiohttp>=3.8.4; extra == "asyncio"
+Requires-Dist: aiofiles>=23.1.0; extra == "asyncio"
+Provides-Extra: kerberos
+Requires-Dist: requests-kerberos>=0.15.0; extra == "kerberos"
+
+# 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.

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

@@ -19,7 +19,7 @@ AUTH_URL = 'https://auth.split.io/api'
 TELEMETRY_URL = 'https://telemetry.split.io/api'
 
 _LOGGER = logging.getLogger(__name__)
-
+_EXC_MSG = '{source} library is throwing exceptions'
 
 HttpResponse = namedtuple('HttpResponse', ['status_code', 'body', 'headers'])
 
@@ -119,10 +119,27 @@ class HttpClientBase(object, metaclass=abc.ABCMeta):
             headers.update(extra_headers)
         return headers
 
+    def _record_telemetry(self, status_code, elapsed):
+        """
+        Record Telemetry info
+
+        :param status_code: http request status code
+        :type status_code: int
+
+        :param elapsed: response time elapsed.
+        :type status_code: int
+        """
+        self._telemetry_runtime_producer.record_sync_latency(self._metric_name, elapsed)
+        if 200 <= status_code < 300:
+            self._telemetry_runtime_producer.record_successful_sync(self._metric_name, get_current_epoch_time_ms())
+            return
+
+        self._telemetry_runtime_producer.record_sync_error(self._metric_name, status_code)
+
 class HttpClient(HttpClientBase):
     """HttpClient wrapper."""
 
-    def __init__(self, timeout=None, sdk_url=None, events_url=None, auth_url=None, telemetry_url=None, authentication_scheme=None, authentication_params=None):
+    def __init__(self, timeout=None, sdk_url=None, events_url=None, auth_url=None, telemetry_url=None):
         """
         Class constructor.
 
@@ -140,9 +157,6 @@ class HttpClient(HttpClientBase):
         _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)
-        self._authentication_scheme = authentication_scheme
-        self._authentication_params = authentication_params
-        self._lock = threading.RLock()
 
     def get(self, server, path, sdk_key, query=None, extra_headers=None):  # pylint: disable=too-many-arguments
         """
@@ -162,22 +176,19 @@ class HttpClient(HttpClientBase):
         :return: Tuple of status_code & response text
         :rtype: HttpResponse
         """
-        with self._lock:
-            start = get_current_epoch_time_ms()
-            with requests.Session() as session:
-                self._set_authentication(session)
-                try:
-                    response = session.get(
-                        _build_url(server, path, self._urls),
-                        params=query,
-                        headers=self._get_headers(extra_headers, sdk_key),
-                        timeout=self._timeout
-                    )
-                    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
-                    raise HttpClientException('requests library is throwing exceptions') from exc
+        start = get_current_epoch_time_ms()
+        try:
+            response = requests.get(
+                _build_url(server, path, self._urls),
+                params=query,
+                headers=self._get_headers(extra_headers, sdk_key),
+                timeout=self._timeout
+            )
+            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
+            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
         """
@@ -199,54 +210,19 @@ class HttpClient(HttpClientBase):
         :return: Tuple of status_code & response text
         :rtype: HttpResponse
         """
-        with self._lock:
-            start = get_current_epoch_time_ms()
-            with requests.Session() as session:
-                self._set_authentication(session)
-                try:
-                    response = session.post(
-                        _build_url(server, path, self._urls),
-                        json=body,
-                        params=query,
-                        headers=self._get_headers(extra_headers, sdk_key),
-                        timeout=self._timeout,
-                    )
-                    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
-                    raise HttpClientException('requests library is throwing exceptions') from exc
-
-    def _set_authentication(self, session):
-        if self._authentication_scheme == AuthenticateScheme.KERBEROS_SPNEGO:
-            _LOGGER.debug("Using Kerberos Spnego Authentication")
-            if self._authentication_params != [None, None]:
-                session.auth = HTTPKerberosAuth(principal=self._authentication_params[0], password=self._authentication_params[1], mutual_authentication=OPTIONAL)
-            else:
-                session.auth = HTTPKerberosAuth(mutual_authentication=OPTIONAL)
-        elif self._authentication_scheme == AuthenticateScheme.KERBEROS_PROXY:
-            _LOGGER.debug("Using Kerberos Proxy Authentication")
-            if self._authentication_params != [None, None]:
-                session.mount('https://', HTTPAdapterWithProxyKerberosAuth(principal=self._authentication_params[0], password=self._authentication_params[1]))
-            else:
-                session.mount('https://', HTTPAdapterWithProxyKerberosAuth())
-
-
-    def _record_telemetry(self, status_code, elapsed):
-        """
-        Record Telemetry info
-
-        :param status_code: http request status code
-        :type status_code: int
-
-        :param elapsed: response time elapsed.
-        :type status_code: int
-        """
-        self._telemetry_runtime_producer.record_sync_latency(self._metric_name, elapsed)
-        if 200 <= status_code < 300:
-            self._telemetry_runtime_producer.record_successful_sync(self._metric_name, get_current_epoch_time_ms())
-            return
-
-        self._telemetry_runtime_producer.record_sync_error(self._metric_name, status_code)
+        start = get_current_epoch_time_ms()
+        try:
+            response = requests.post(
+                _build_url(server, path, self._urls),
+                json=body,
+                params=query,
+                headers=self._get_headers(extra_headers, sdk_key),
+                timeout=self._timeout,
+            )
+            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
+            raise HttpClientException(_EXC_MSG.format(source='request')) from exc
 
 class HttpClientAsync(HttpClientBase):
     """HttpClientAsync wrapper."""
@@ -306,7 +282,7 @@ class HttpClientAsync(HttpClientBase):
                 return HttpResponse(response.status, body, response.headers)
 
         except aiohttp.ClientError as exc:  # pylint: disable=broad-except
-            raise HttpClientException('aiohttp library is throwing exceptions') from exc
+            raise HttpClientException(_EXC_MSG.format(source='aiohttp')) from exc
 
     async def post(self, server, path, apikey, body, query=None, extra_headers=None):  # pylint: disable=too-many-arguments
         """
@@ -350,7 +326,7 @@ class HttpClientAsync(HttpClientBase):
                 return HttpResponse(response.status, body, response.headers)
 
         except aiohttp.ClientError as exc:  # pylint: disable=broad-except
-            raise HttpClientException('aiohttp library is throwing exceptions') from exc
+            raise HttpClientException(_EXC_MSG.format(source='aiohttp')) from exc
 
     async def _record_telemetry(self, status_code, elapsed):
         """
@@ -372,3 +348,191 @@ class HttpClientAsync(HttpClientBase):
     async def close_session(self):
         if not self._session.closed:
             await self._session.close()
+
+class HttpClientKerberos(HttpClientBase):
+    """HttpClient wrapper."""
+
+    def __init__(self, timeout=None, sdk_url=None, events_url=None, auth_url=None, telemetry_url=None, authentication_scheme=None, authentication_params=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
+        :param authentication_scheme: Optional authentication scheme to use.
+        :type authentication_scheme: splitio.client.config.AuthenticateScheme
+        :param authentication_params: Optional authentication username and password to use.
+        :type authentication_params: [str, str]
+        """
+        _LOGGER.debug("Initializing httpclient for Kerberos auth")
+        self._timeout = timeout/1000 if timeout else None # Convert ms to seconds.
+        self._urls = _construct_urls(sdk_url, events_url, auth_url, telemetry_url)
+        self._authentication_scheme = authentication_scheme
+        self._authentication_params = authentication_params
+        self._lock = threading.RLock()
+        self._sessions = {'sdk': requests.Session(),
+                          'events': requests.Session(),
+                          'auth': requests.Session(),
+                          'telemetry': requests.Session()}
+        self._set_authentication()
+
+    def get(self, server, path, sdk_key, query=None, extra_headers=None):  # pylint: disable=too-many-arguments
+        """
+        Issue a get request.
+        :param server: Whether the request is for SDK server, Events server or Auth server.
+        :typee server: str
+        :param path: path to append to the host url.
+        :type path: str
+        :param sdk_key: sdk key.
+        :type sdk_key: str
+        :param query: Query string passed as dictionary.
+        :type query: dict
+        :param extra_headers: key/value pairs of possible extra headers.
+        :type extra_headers: dict
+
+        :return: Tuple of status_code & response text
+        :rtype: HttpResponse
+        """
+        with self._lock:
+            start = get_current_epoch_time_ms()
+            try:
+                return self._do_get(server, path, sdk_key, query, extra_headers, start)
+
+            except requests.exceptions.ProxyError as exc:
+                _LOGGER.debug("Proxy Exception caught, resetting the http session")
+                self._sessions[server].close()
+                self._sessions[server] = requests.Session()
+                self._set_authentication(server_name=server)
+                try:
+                    return self._do_get(server, path, sdk_key, query, extra_headers, start)
+
+                except Exception as exc:
+                    raise HttpClientException(_EXC_MSG.format(source='request')) from exc
+
+            except Exception as exc:  # pylint: disable=broad-except
+                raise HttpClientException(_EXC_MSG.format(source='request')) from exc
+
+    def _do_get(self, server, path, sdk_key, query, extra_headers, start):
+        """
+        Issue a get request.
+        :param server: Whether the request is for SDK server, Events server or Auth server.
+        :typee server: str
+        :param path: path to append to the host url.
+        :type path: str
+        :param sdk_key: sdk key.
+        :type sdk_key: str
+        :param query: Query string passed as dictionary.
+        :type query: dict
+        :param extra_headers: key/value pairs of possible extra headers.
+        :type extra_headers: dict
+
+        :return: Tuple of status_code & response text
+        :rtype: HttpResponse
+        """
+        with self._sessions[server].get(
+            _build_url(server, path, self._urls),
+            headers=self._get_headers(extra_headers, sdk_key),
+            params=query,
+            timeout=self._timeout
+        ) as response:
+            self._record_telemetry(response.status_code, get_current_epoch_time_ms() - start)
+            return HttpResponse(response.status_code, response.text, response.headers)
+
+    def post(self, server, path, sdk_key, body, query=None, extra_headers=None):  # pylint: disable=too-many-arguments
+        """
+        Issue a POST request.
+
+        :param server: Whether the request is for SDK server or Events server.
+        :typee server: str
+        :param path: path to append to the host url.
+        :type path: str
+        :param sdk_key: sdk key.
+        :type sdk_key: str
+        :param body: body sent in the request.
+        :type body: str
+        :param query: Query string passed as dictionary.
+        :type query: dict
+        :param extra_headers: key/value pairs of possible extra headers.
+        :type extra_headers: dict
+
+        :return: Tuple of status_code & response text
+        :rtype: HttpResponse
+        """
+        with self._lock:
+            start = get_current_epoch_time_ms()
+            try:
+                return self._do_post(server, path, sdk_key, query, extra_headers, body, start)
+
+            except requests.exceptions.ProxyError as exc:
+                _LOGGER.debug("Proxy Exception caught, resetting the http session")
+                self._sessions[server].close()
+                self._sessions[server] = requests.Session()
+                self._set_authentication(server_name=server)
+                try:
+                    return self._do_post(server, path, sdk_key, query, extra_headers, body, start)
+
+                except Exception as exc:
+                    raise HttpClientException(_EXC_MSG.format(source='request')) from exc
+
+            except Exception as exc:  # pylint: disable=broad-except
+                raise HttpClientException(_EXC_MSG.format(source='request')) from exc
+
+    def _do_post(self, server, path, sdk_key, query, extra_headers, body, start):
+        """
+        Issue a POST request.
+
+        :param server: Whether the request is for SDK server or Events server.
+        :typee server: str
+        :param path: path to append to the host url.
+        :type path: str
+        :param sdk_key: sdk key.
+        :type sdk_key: str
+        :param body: body sent in the request.
+        :type body: str
+        :param query: Query string passed as dictionary.
+        :type query: dict
+        :param extra_headers: key/value pairs of possible extra headers.
+        :type extra_headers: dict
+
+        :return: Tuple of status_code & response text
+        :rtype: HttpResponse
+        """
+        with self._sessions[server].post(
+            _build_url(server, path, self._urls),
+            params=query,
+            headers=self._get_headers(extra_headers, sdk_key),
+            json=body,
+            timeout=self._timeout,
+        ) as response:
+            self._record_telemetry(response.status_code, get_current_epoch_time_ms() - start)
+            return HttpResponse(response.status_code, response.text, response.headers)
+
+    def _set_authentication(self, server_name=None):
+        """
+        Set the authentication for all self._sessions variables based on authentication scheme.
+
+        :param server: If set, will only add the auth for its session variable, otherwise will set all sessions.
+        :typee server: str
+        """
+        for server in ['sdk', 'events', 'auth', 'telemetry']:
+            if server_name is not None and server_name != server:
+                continue
+            if self._authentication_scheme == AuthenticateScheme.KERBEROS_SPNEGO:
+                _LOGGER.debug("Using Kerberos Spnego Authentication")
+                if self._authentication_params != [None, None]:
+                    self._sessions[server].auth = HTTPKerberosAuth(principal=self._authentication_params[0], password=self._authentication_params[1], mutual_authentication=OPTIONAL)
+                else:
+                    self._sessions[server].auth = HTTPKerberosAuth(mutual_authentication=OPTIONAL)
+            elif self._authentication_scheme == AuthenticateScheme.KERBEROS_PROXY:
+                _LOGGER.debug("Using Kerberos Proxy Authentication")
+                if self._authentication_params != [None, None]:
+                    self._sessions[server].mount('https://', HTTPAdapterWithProxyKerberosAuth(principal=self._authentication_params[0], password=self._authentication_params[1]))
+                else:
+                    self._sessions[server].mount('https://', HTTPAdapterWithProxyKerberosAuth())

{splitio_client-10.1.0rc2 → splitio_client-10.2.0}/splitio/client/client.py

@@ -3,7 +3,7 @@ import logging
 
 from splitio.engine.evaluator import Evaluator, CONTROL, EvaluationDataFactory, AsyncEvaluationDataFactory
 from splitio.engine.splitters import Splitter
-from splitio.models.impressions import Impression, Label
+from splitio.models.impressions import Impression, Label, ImpressionDecorated
 from splitio.models.events import Event, EventWrapper
 from splitio.models.telemetry import get_latency_bucket_index, MethodExceptionsAndLatencies
 from splitio.client import input_validator
@@ -22,7 +22,8 @@ class ClientBase(object):  # pylint: disable=too-many-instance-attributes
         'impression': {
             'label': Label.EXCEPTION,
             'change_number': None,
-        }
+        },
+        'impressions_disabled': False
     }
 
     _NON_READY_EVAL_RESULT = {
@@ -31,7 +32,8 @@ class ClientBase(object):  # pylint: disable=too-many-instance-attributes
         'impression': {
             'label': Label.NOT_READY,
             'change_number': None
-        }
+        },
+        'impressions_disabled': False
     }
 
     def __init__(self, factory, recorder, labels_enabled=True):
@@ -116,14 +118,15 @@ class ClientBase(object):  # pylint: disable=too-many-instance-attributes
 
     def _build_impression(self, key, bucketing, feature, result):
         """Build an impression based on evaluation data & it's result."""
-        return Impression(
-                matching_key=key,
+        return ImpressionDecorated(
+                Impression(matching_key=key,
                 feature_name=feature,
                 treatment=result['treatment'],
                 label=result['impression']['label'] if self._labels_enabled else None,
                 change_number=result['impression']['change_number'],
                 bucketing_key=bucketing,
-                time=utctime_ms())
+                time=utctime_ms()),
+                disabled=result['impressions_disabled'])
 
     def _build_impressions(self, key, bucketing, results):
         """Build an impression based on evaluation data & it's result."""
@@ -296,8 +299,8 @@ class Client(ClientBase):  # pylint: disable=too-many-instance-attributes
                 result = self._FAILED_EVAL_RESULT
 
         if result['impression']['label'] != Label.SPLIT_NOT_FOUND:
-            impression = self._build_impression(key, bucketing, feature, result)
-            self._record_stats([(impression, attributes)], start, method)
+            impression_decorated = self._build_impression(key, bucketing, feature, result)
+            self._record_stats([(impression_decorated, attributes)], start, method)
 
         return result['treatment'], result['configurations']
 
@@ -571,23 +574,23 @@ class Client(ClientBase):  # pylint: disable=too-many-instance-attributes
                 self._telemetry_evaluation_producer.record_exception(method)
                 results = {n: self._FAILED_EVAL_RESULT for n in features}
 
-        imp_attrs = [
+        imp_decorated_attrs = [
             (i, attributes) for i in self._build_impressions(key, bucketing, results)
-            if i.label != Label.SPLIT_NOT_FOUND
+            if i.Impression.label != Label.SPLIT_NOT_FOUND
         ]
-        self._record_stats(imp_attrs, start, method)
+        self._record_stats(imp_decorated_attrs, start, method)
 
         return {
             feature: (results[feature]['treatment'], results[feature]['configurations'])
             for feature in results
         }
 
-    def _record_stats(self, impressions, start, operation):
+    def _record_stats(self, impressions_decorated, start, operation):
         """
         Record impressions.
 
-        :param impressions: Generated impressions
-        :type impressions: list[tuple[splitio.models.impression.Impression, dict]]
+        :param impressions_decorated: Generated impressions
+        :type impressions_decorated: list[tuple[splitio.models.impression.ImpressionDecorated, dict]]
 
         :param start: timestamp when get_treatment or get_treatments was called
         :type start: int
@@ -596,7 +599,7 @@ class Client(ClientBase):  # pylint: disable=too-many-instance-attributes
         :type operation: str
         """
         end = get_current_epoch_time_ms()
-        self._recorder.record_treatment_stats(impressions, get_latency_bucket_index(end - start),
+        self._recorder.record_treatment_stats(impressions_decorated, get_latency_bucket_index(end - start),
                                               operation, 'get_' + operation.value)
 
     def track(self, key, traffic_type, event_type, value=None, properties=None):
@@ -763,8 +766,8 @@ class ClientAsync(ClientBase):  # pylint: disable=too-many-instance-attributes
                 result = self._FAILED_EVAL_RESULT
 
         if result['impression']['label'] != Label.SPLIT_NOT_FOUND:
-            impression = self._build_impression(key, bucketing, feature, result)
-            await self._record_stats([(impression, attributes)], start, method)
+            impression_decorated = self._build_impression(key, bucketing, feature, result)
+            await self._record_stats([(impression_decorated, attributes)], start, method)
         return result['treatment'], result['configurations']
 
     async def get_treatments(self, key, feature_flag_names, attributes=None):
@@ -960,23 +963,23 @@ class ClientAsync(ClientBase):  # pylint: disable=too-many-instance-attributes
                 await self._telemetry_evaluation_producer.record_exception(method)
                 results = {n: self._FAILED_EVAL_RESULT for n in features}
 
-        imp_attrs = [
+        imp_decorated_attrs = [
             (i, attributes) for i in self._build_impressions(key, bucketing, results)
-            if i.label != Label.SPLIT_NOT_FOUND
+            if i.Impression.label != Label.SPLIT_NOT_FOUND
         ]
-        await self._record_stats(imp_attrs, start, method)
+        await self._record_stats(imp_decorated_attrs, start, method)
 
         return {
             feature: (res['treatment'], res['configurations'])
             for feature, res in results.items()
         }
 
-    async def _record_stats(self, impressions, start, operation):
+    async def _record_stats(self, impressions_decorated, start, operation):
         """
         Record impressions for async calls
 
-        :param impressions: Generated impressions
-        :type impressions: list[tuple[splitio.models.impression.Impression, dict]]
+        :param impressions_decorated: Generated impressions decorated
+        :type impressions_decorated: list[tuple[splitio.models.impression.Impression, dict]]
 
         :param start: timestamp when get_treatment or get_treatments was called
         :type start: int
@@ -985,7 +988,7 @@ class ClientAsync(ClientBase):  # pylint: disable=too-many-instance-attributes
         :type operation: str
         """
         end = get_current_epoch_time_ms()
-        await self._recorder.record_treatment_stats(impressions, get_latency_bucket_index(end - start),
+        await self._recorder.record_treatment_stats(impressions_decorated, get_latency_bucket_index(end - start),
                                               operation, 'get_' + operation.value)
 
     async def track(self, key, traffic_type, event_type, value=None, properties=None):