Merge pull request #344 from splitio/dw-client-log-func-comments

Dw client log func comments

Author: chillaq

doc/source/introduction.rst

@@ -26,7 +26,7 @@ The following snippet shows you how to create a basic client using the default c
   >>> from splitio import get_factory
   >>> factory = get_factory('some_api_key')
   >>> client = factory.client()
-  >>> client.get_treatment('some_user', 'some_feature_flag')
+  >>> client.get_treatment('some_user', 'some_feature')
   'SOME_TREATMENT'
 
 Bucketing key
@@ -39,11 +39,11 @@ In advanced mode the key can be set as two different parts, one of them just to
   >>> split_key = Key(user, bucketing_key)
   >>> factory = get_factory('API_KEY')
   >>> client = factory.client()
-  >>> client.get_treatment(split_key, 'some_feature_flag')
+  >>> client.get_treatment(split_key, 'some_feature')
 
 Manager API
 -----------
-Manager API is very useful to get a representation (view) of cached feature flags: ::
+Manager API is very useful to get a representation (view) of cached splits: ::
 
   >>> from splitio import get_factory
   >>> factory = get_factory('API_KEY')
@@ -57,7 +57,7 @@ Available methods:
 **split(name):** Returns a SplitView instance ::
   >>> manager.split('some_test_name')
 
-**split_names():** Returns a list of Feature Flag names (String) ::
+**split_names():** Returns a list of Split names (String) ::
   >>> manager.split_names()
 
 Client configuration
@@ -79,7 +79,7 @@ All the possible configuration options are:
 +------------------------+------+--------------------------------------------------------+---------+
 | readTimeout            | int  | The read timeout for HTTP connections in milliseconds. | 1500    |
 +------------------------+------+--------------------------------------------------------+---------+
-| featuresRefreshRate    | int  | The feature flags update refresh period in             | 5       |
+| featuresRefreshRate    | int  | The features (splits) update refresh period in         | 5      |
 |                        |      | seconds.                                               |         |
 +------------------------+------+--------------------------------------------------------+---------+
 | segmentsRefreshRate    | int  | The segments update refresh period in seconds.         | 60      |
@@ -88,10 +88,10 @@ All the possible configuration options are:
 +------------------------+------+--------------------------------------------------------+---------+
 | impressionsRefreshRate | int  | The impressions report period in seconds               | 60      |
 +------------------------+------+--------------------------------------------------------+---------+
-| ready                  | int  | How long to wait (in milliseconds) for the feature     |         |
-|                        |      | flags and segments information to be available. If     |         |
-|                        |      | the timeout is exceeded, a ``TimeoutException`` will   |         |
-|                        |      | be raised. If value is 0, the constructor will return  |         |
+| ready                  | int  | How long to wait (in milliseconds) for the features    |         |
+|                        |      | and segments information to be available. If the       |         |
+|                        |      | timeout is exceeded, a ``TimeoutException`` will be    |         |
+|                        |      | raised. If value is 0, the constructor will return     |         |
 |                        |      | immediately but not all the information might be       |         |
 |                        |      | available right away.                                  |         |
 +------------------------+------+--------------------------------------------------------+---------+
@@ -106,31 +106,31 @@ directory. The ``.split`` file has the following format: ::
 
   file: (comment | split_line)+
   comment : '#' string*\n
-  split_line : feature_flag_name ' ' treatment\n
-  feature_flag_name : string
+  split_line : feature_name ' ' treatment\n
+  feature_name : string
   treatment : string
 
 This is an example of a ``.split`` file: ::
 
   # This is a comment
-  feature_flag_0 treatment_0
-  feature_flag_1 treatment_1
+  feature_0 treatment_0
+  feature_1 treatment_1
 
-Whenever a treatment is requested for the feature flag ``feature_flag_0``, ``treatment_0`` is going to be returned. The same goes for ``feature_flag_1`` and ``treatment_1``. The following example illustrates the behaviour: ::
+Whenever a treatment is requested for the feature ``feature_0``, ``treatment_0`` is going to be returned. The same goes for ``feature_1`` and ``treatment_1``. The following example illustrates the behaviour: ::
 
   >>> from splitio import get_factory
   >>> factory = get_factory('localhost')
   >>> client = factory.client()
-  >>> client.get_treatment('some_user', 'feature_flag_0')
+  >>> client.get_treatment('some_user', 'feature_0')
   'treatment_0'
-  >>> client.get_treatment('some_other_user', 'feature_flag_0')
+  >>> client.get_treatment('some_other_user', 'feature_0')
   'treatment_0'
-  >>> client.get_treatment('yet_another_user', 'feature_flag_1')
+  >>> client.get_treatment('yet_another_user', 'feature_1')
   'treatment_1'
-  >>> client.get_treatment('some_user', 'non_existent_feature_flag')
+  >>> client.get_treatment('some_user', 'non_existent_feature')
   'CONTROL'
 
-Notice that an API key is not necessary for the localhost environment, and the ``CONTROL`` is returned for non existent feature flags.
+Notice that an API key is not necessary for the localhost environment, and the ``CONTROL`` is returned for non existent features.
 
 It is possible to specify a different splits file using the ``split_definition_file_name`` argument: ::
 
@@ -161,7 +161,7 @@ Before you can use it, you need to install the ``splitio_client`` with support f
 
   pip install splitio_client[redis]
 
-The client depends on the information for feature flags and segments being updated externally. In order to do that, we provide the ``update_splits`` and ``update_segments`` scripts or even the ``splitio.bin.synchronizer`` service.
+The client depends on the information for features and segments being updated externally. In order to do that, we provide the ``update_splits`` and ``update_segments`` scripts or even the ``splitio.bin.synchronizer`` service.
 
 The scripts are configured through a JSON settings file, like the following: ::
 
@@ -198,7 +198,7 @@ These are the possible configuration parameters:
 | redisDb                | int  | The db number on the Redis instance                    | 0                             |
 +------------------------+------+--------------------------------------------------------+-------------------------------+
 
-Let's assume that the configuration file is called ``splitio-config.json`` and that the client is installed in a virtualenv in ``/home/user/venv``. The feature flag update script can be run with: ::
+Let's assume that the configuration file is called ``splitio-config.json`` and that the client is installed in a virtualenv in ``/home/user/venv``. The feature update script can be run with: ::
 
   $ /home/user/venv/bin/python -m splitio.update_scripts.update_splits splitio-config.json
 

splitio/client/client.py

@@ -116,7 +116,7 @@ def _make_evaluation(self, key, feature, attributes, method_name, metric_name):
             self._record_stats([(impression, attributes)], start, metric_name, method_name)
             return result['treatment'], result['configurations']
         except Exception as e:  # pylint: disable=broad-except
-            _LOGGER.error('Error getting treatment for feature')
+            _LOGGER.error('Error getting treatment for feature flag')
             _LOGGER.error(str(e))
             _LOGGER.debug('Error: ', exc_info=True)
             self._telemetry_evaluation_producer.record_exception(metric_name)
@@ -185,7 +185,7 @@ def _make_evaluations(self, key, features, attributes, method_name, metric_name)
 
                 except Exception:  # pylint: disable=broad-except
                     _LOGGER.error('%s: An exception occured when evaluating '
-                                  'feature %s returning CONTROL.' % (method_name, feature))
+                                  'feature flag %s returning CONTROL.' % (method_name, feature))
                     treatments[feature] = CONTROL, None
                     _LOGGER.debug('Error: ', exc_info=True)
                     continue
@@ -208,7 +208,7 @@ def _make_evaluations(self, key, features, attributes, method_name, metric_name)
             return treatments
         except Exception:  # pylint: disable=broad-except
             self._telemetry_evaluation_producer.record_exception(metric_name)
-            _LOGGER.error('Error getting treatment for features')
+            _LOGGER.error('Error getting treatment for feature flags')
             _LOGGER.debug('Error: ', exc_info=True)
         return input_validator.generate_control_treatments(list(features), method_name)
 
@@ -233,37 +233,37 @@ def _evaluate_features_if_ready(self, matching_key, bucketing_key, features, att
 
     def get_treatment_with_config(self, key, feature, attributes=None):
         """
-        Get the treatment and config for a feature and key, with optional dictionary of attributes.
+        Get the treatment and config for a feature flag and key, with optional dictionary of attributes.
 
         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 feature: The name of the feature for which to get the treatment
+        :param feature: The name of the feature flag for which to get the treatment
         :type feature: str
         :param attributes: An optional dictionary of attributes
         :type attributes: dict
-        :return: The treatment for the key and feature
+        :return: The treatment for the key and feature flag
         :rtype: tuple(str, str)
         """
         return self._make_evaluation(key, feature, attributes, 'get_treatment_with_config',
                                      MethodExceptionsAndLatencies.TREATMENT_WITH_CONFIG)
 
     def get_treatment(self, key, feature, attributes=None):
         """
-        Get the treatment for a feature and key, with an optional dictionary of attributes.
+        Get the treatment for a feature flag and key, with an optional dictionary of attributes.
 
         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 feature: The name of the feature for which to get the treatment
+        :param feature: The name of the feature flag for which to get the treatment
         :type feature: str
         :param attributes: An optional dictionary of attributes
         :type attributes: dict
-        :return: The treatment for the key and feature
+        :return: The treatment for the key and feature flag
         :rtype: str
         """
         treatment, _ = self._make_evaluation(key, feature, attributes, 'get_treatment',
@@ -272,37 +272,37 @@ def get_treatment(self, key, feature, attributes=None):
 
     def get_treatments_with_config(self, key, features, attributes=None):
         """
-        Evaluate multiple features and return a dict with feature -> (treatment, config).
+        Evaluate multiple feature flags and return a dict with feature flag -> (treatment, config).
 
-        Get the treatments for a list of features considering a key, with an optional dictionary of
+        Get the treatments for a list of feature flags considering a key, with an optional dictionary of
         attributes. 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 features: Array of the names of the features for which to get the treatment
+        :param features: Array of the names of the feature flags for which to get the treatment
         :type feature: list
         :param attributes: An optional dictionary of attributes
         :type attributes: dict
-        :return: Dictionary with the result of all the features provided
+        :return: Dictionary with the result of all the feature flags provided
         :rtype: dict
         """
         return self._make_evaluations(key, features, attributes, 'get_treatments_with_config',
                                       MethodExceptionsAndLatencies.TREATMENTS_WITH_CONFIG)
 
     def get_treatments(self, key, features, attributes=None):
         """
-        Evaluate multiple features and return a dictionary with all the feature/treatments.
+        Evaluate multiple feature flags and return a dictionary with all the feature flag/treatments.
 
-        Get the treatments for a list of features considering a key, with an optional dictionary of
+        Get the treatments for a list of feature flags considering a key, with an optional dictionary of
         attributes. 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 features: Array of the names of the features for which to get the treatment
+        :param features: Array of the names of the feature flags for which to get the treatment
         :type feature: list
         :param attributes: An optional dictionary of attributes
         :type attributes: dict
-        :return: Dictionary with the result of all the features provided
+        :return: Dictionary with the result of all the feature flags provided
         :rtype: dict
         """
         with_config = self._make_evaluations(key, features, attributes, 'get_treatments',