Revert "App Config - Feature Flag load/refresh (#33411)" (#33725)

This reverts commit 97f43d2.

Author: mrm9084

sdk/appconfiguration/azure-appconfiguration-provider/assets.json

@@ -2,5 +2,5 @@
   "AssetsRepo": "Azure/azure-sdk-assets",
   "AssetsRepoPrefixPath": "python",
   "TagPrefix": "python/appconfiguration/azure-appconfiguration-provider",
-  "Tag": "python/appconfiguration/azure-appconfiguration-provider_29963ddf05"
+  "Tag": "python/appconfiguration/azure-appconfiguration-provider_51fb3fb738"
 }

sdk/appconfiguration/azure-appconfiguration-provider/azure/appconfiguration/provider/_azureappconfigurationprovider.py

@@ -100,17 +100,6 @@ def load(
     :paramtype on_refresh_error: Optional[Callable[[Exception], None]]
     :keyword on_refresh_error: Optional callback to be invoked when an error occurs while refreshing settings. If not
     specified, errors will be raised.
-    :paramtype feature_flag_enabled: bool
-    :keyword feature_flag_enabled: Optional flag to enable or disable the loading of feature flags. Default is False.
-    :paramtype feature_flag_selectors: List[SettingSelector]
-    :keyword feature_flag_selectors: Optional list of selectors to filter feature flags. By default will load all
-    feature flags without a label.
-    :paramtype feature_flag_refresh_enabled: bool
-    :keyword feature_flag_refresh_enabled: Optional flag to enable or disable the refresh of feature flags. Default is
-     False.
-    :paramtype feature_flag_trim_prefixes: List[str]
-    :keyword feature_flag_trim_prefixes: After the FEATURE_FLAG_PREFIX is trimmed, the first match in
-    feature_flag_trim_prefixes will be trimmed, if there is one.
     """
 
 
@@ -155,17 +144,6 @@ def load(
     :paramtype on_refresh_error: Optional[Callable[[Exception], None]]
     :keyword on_refresh_error: Optional callback to be invoked when an error occurs while refreshing settings. If not
     specified, errors will be raised.
-    :paramtype feature_flag_enabled: bool
-    :keyword feature_flag_enabled: Optional flag to enable or disable the loading of feature flags. Default is False.
-    :paramtype feature_flag_selectors: List[SettingSelector]
-    :keyword feature_flag_selectors: Optional list of selectors to filter feature flags. By default will load all
-    feature flags without a label.
-    :paramtype feature_flag_refresh_enabled: bool
-    :keyword feature_flag_refresh_enabled: Optional flag to enable or disable the refresh of feature flags. Default is
-     False.
-    :paramtype feature_flag_trim_prefixes: List[str]
-    :keyword feature_flag_trim_prefixes: After the FEATURE_FLAG_PREFIX is trimmed, the first match in
-    feature_flag_trim_prefixes will be trimmed, if there is one.
     """
 
 
@@ -460,19 +438,12 @@ def __init__(self, **kwargs) -> None:
             or self._keyvault_client_configs is not None
             or self._secret_resolver is not None
         )
-        self._feature_flag_enabled = kwargs.pop("feature_flag_enabled", False)
-        self._feature_flag_selectors = kwargs.pop("feature_flag_selectors", [SettingSelector(key_filter="*")])
-        self._refresh_on_feature_flags = None
-        self._feature_flag_refresh_timer: _RefreshTimer = _RefreshTimer(**kwargs)
-        self._feature_flag_refresh_enabled = kwargs.pop("feature_flag_refresh_enabled", False)
-        feature_flag_trim_prefixes = kwargs.pop("feature_flag_trim_prefixes", [])
-        self._feature_flag_trim_prefixes: List[str] = sorted(feature_flag_trim_prefixes, key=len, reverse=True)
         self._update_lock = Lock()
         self._refresh_lock = Lock()
 
     def refresh(self, **kwargs) -> None:
-        if not self._refresh_on and not self._feature_flag_refresh_enabled:
-            logging.debug("Refresh called but no refresh enabled.")
+        if not self._refresh_on:
+            logging.debug("Refresh called but no refresh options set.")
             return
         if not self._refresh_timer.needs_refresh():
             logging.debug("Refresh called but refresh interval not elapsed.")
@@ -532,76 +503,7 @@ def refresh(self, **kwargs) -> None:
             elif need_refresh and self._on_refresh_success:
                 self._on_refresh_success()
 
-    def refresh_configuration_settings(self, configuration_settings, sentinel_keys, timer, **kwargs) -> None:
-        success = False
-        need_refresh = False
-        updated_feature_flags = False
-        headers = _get_headers("Watch", uses_key_vault=self._uses_key_vault, **kwargs)
-        try:
-            for (key, label), etag in sentinel_keys.items():
-                etag, update, is_feature_flag, configuration_settings = self._check_configuration_settings(
-                    key, label, etag, headers, configuration_settings, **kwargs
-                )
-                if update and not is_feature_flag:
-                    need_refresh = True
-                elif update and is_feature_flag:
-                    updated_feature_flags = True
-
-                sentinel_keys[(key, label)] = etag
-            # Need to only update once, no matter how many sentinels are updated
-            if need_refresh:
-                configuration_settings, sentinel_keys = self._load_configuration_settings(
-                    headers=headers, sentinel_keys=sentinel_keys, **kwargs
-                )
-            success = True
-            # Even if we don't need to refresh, we should reset the timer
-            timer.reset()
-        except (ServiceRequestError, ServiceResponseError, HttpResponseError) as e:
-            # If a call back is provided, we should call it, otherwise raise the error
-            if not self._on_refresh_error:
-                raise
-            self._on_refresh_error(e)
-        finally:
-            # If we get an error we should retry sooner than the next refresh interval
-            if not success:
-                timer.backoff()
-        return configuration_settings, sentinel_keys, need_refresh or updated_feature_flags
-
-    def _check_configuration_settings(self, key, label, etag, headers, configuration_settings, **kwargs) -> None:
-        is_feature_flag = False
-        try:
-            updated_config = self._client.get_configuration_setting(
-                key=key, label=label, etag=etag, match_condition=MatchConditions.IfModified, headers=headers, **kwargs
-            )
-            is_feature_flag = not isinstance(updated_config, FeatureFlagConfigurationSetting)
-            if updated_config is not None:
-                if not is_feature_flag:
-                    logging.debug("Refresh all triggered by key: %s label %s.", key, label)
-                elif is_feature_flag:
-                    configuration_settings[self._process_key_name(updated_config)] = updated_config.value
-                return updated_config.etag, True, is_feature_flag, configuration_settings
-        except HttpResponseError as e:
-            if e.status_code == 404:
-                if etag is not None and not is_feature_flag:
-                    # If the sentinel is not found, it means the key/label was deleted, so we should refresh
-                    logging.debug("Refresh all triggered by key: %s label %s.", key, label)
-                elif etag is not None and is_feature_flag:
-                    configuration_settings[key] = None
-                return None, True, is_feature_flag, configuration_settings
-            raise e
-        return etag, False, is_feature_flag, configuration_settings
-
     def _load_all(self, **kwargs):
-        configuration_settings, sentinel_keys = self._load_configuration_settings(**kwargs)
-        feature_flags, feature_flag_sentinel_keys = self._load_feature_flags(**kwargs)
-        if self._feature_flag_enabled:
-            configuration_settings[FEATURE_MANAGEMENT_KEY] = feature_flags
-            self._refresh_on_feature_flags = feature_flag_sentinel_keys
-        with self._update_lock:
-            self._refresh_on = sentinel_keys
-            self._dict = configuration_settings
-
-    def _load_configuration_settings(self, **kwargs):
         configuration_settings = {}
         sentinel_keys = kwargs.pop("sentinel_keys", self._refresh_on)
         for select in self._selects:
@@ -612,51 +514,30 @@ def _load_configuration_settings(self, **kwargs):
                 key = self._process_key_name(config)
                 value = self._process_key_value(config)
                 if isinstance(config, FeatureFlagConfigurationSetting):
-                    # Feature flags are ignored when loaded by Selects, as they are selected from
-                    # `feature_flag_selectors`
-                    pass
+                    feature_management = configuration_settings.get(FEATURE_MANAGEMENT_KEY, {})
+                    feature_management[key] = value
+                    if FEATURE_MANAGEMENT_KEY not in configuration_settings:
+                        configuration_settings[FEATURE_MANAGEMENT_KEY] = feature_management
                 else:
                     configuration_settings[key] = value
                 # Every time we run load_all, we should update the etag of our refresh sentinels
                 # so they stay up-to-date.
                 # Sentinel keys will have unprocessed key names, so we need to use the original key.
                 if (config.key, config.label) in self._refresh_on:
                     sentinel_keys[(config.key, config.label)] = config.etag
-        return configuration_settings, sentinel_keys
-
-    def _load_feature_flags(self, **kwargs):
-        feature_flag_sentinel_keys = {}
-        loaded_feature_flags = {}
-        if self._feature_flag_enabled:
-            for select in self._feature_flag_selectors:
-                feature_flags = self._client.list_configuration_settings(
-                    key_filter=FEATURE_FLAG_PREFIX + select.key_filter, label_filter=select.label_filter, **kwargs
-                )
-                for feature_flag in feature_flags:
-                    key = self._process_key_name(feature_flag)
-                    loaded_feature_flags[key] = feature_flag.value
-                    if self._feature_flag_refresh_enabled:
-                        feature_flag_sentinel_keys[(feature_flag.key, feature_flag.label)] = feature_flag.etag
-        return loaded_feature_flags, feature_flag_sentinel_keys
+        self._refresh_on = sentinel_keys
+        with self._update_lock:
+            self._dict = configuration_settings
 
     def _process_key_name(self, config):
         trimmed_key = config.key
         # Trim the key if it starts with one of the prefixes provided
-
-        # Feature Flags have there own prefix, so we need to trim that first
-        if isinstance(config, FeatureFlagConfigurationSetting):
-            if trimmed_key.startswith(FEATURE_FLAG_PREFIX):
-                trimmed_key = trimmed_key[len(FEATURE_FLAG_PREFIX) :]
-            for trim in self._feature_flag_trim_prefixes:
-                if trimmed_key.startswith(trim):
-                    trimmed_key = trimmed_key[len(trim) :]
-                    break
-            return trimmed_key
-
         for trim in self._trim_prefixes:
             if config.key.startswith(trim):
                 trimmed_key = config.key[len(trim) :]
                 break
+        if isinstance(config, FeatureFlagConfigurationSetting) and trimmed_key.startswith(FEATURE_FLAG_PREFIX):
+            return trimmed_key[len(FEATURE_FLAG_PREFIX) :]
         return trimmed_key
 
     def _process_key_value(self, config):

sdk/appconfiguration/azure-appconfiguration-provider/azure/appconfiguration/provider/_constants.py

@@ -4,7 +4,7 @@
 # license information.
 # -------------------------------------------------------------------------
 
-FEATURE_MANAGEMENT_KEY = "FeatureManagement"
+FEATURE_MANAGEMENT_KEY = "FeatureManagementFeatureFlags"
 FEATURE_FLAG_PREFIX = ".appconfig.featureflag/"
 
 EMPTY_LABEL = "\0"

sdk/appconfiguration/azure-appconfiguration-provider/samples/feature_flag_sample.py

@@ -27,7 +27,6 @@ async def create_aad_client(
         secret_resolver=None,
         key_vault_options=None,
         on_refresh_success=None,
-        feature_flag_enabled=False,
     ):
         cred = self.get_credential(AzureAppConfigurationClient, is_async=True)
 
@@ -51,7 +50,6 @@ async def create_aad_client(
                 user_agent="SDK/Integration",
                 keyvault_credential=keyvault_cred,
                 on_refresh_success=on_refresh_success,
-                feature_flag_enabled=feature_flag_enabled,
             )
         if key_vault_options:
             if not key_vault_options.secret_resolver:
@@ -66,7 +64,6 @@ async def create_aad_client(
                 user_agent="SDK/Integration",
                 key_vault_options=key_vault_options,
                 on_refresh_success=on_refresh_success,
-                feature_flag_enabled=feature_flag_enabled,
             )
         return await load(
             credential=cred,
@@ -78,7 +75,6 @@ async def create_aad_client(
             user_agent="SDK/Integration",
             secret_resolver=secret_resolver,
             on_refresh_success=on_refresh_success,
-            feature_flag_enabled=feature_flag_enabled,
         )
 
     async def create_client(
@@ -92,7 +88,6 @@ async def create_client(
         secret_resolver=None,
         key_vault_options=None,
         on_refresh_success=None,
-        feature_flag_enabled=False,
     ):
         client = AzureAppConfigurationClient.from_connection_string(appconfiguration_connection_string)
         await setup_configs(client, keyvault_secret_url)
@@ -107,7 +102,6 @@ async def create_client(
                 user_agent="SDK/Integration",
                 keyvault_credential=self.get_credential(AzureAppConfigurationClient, is_async=True),
                 on_refresh_success=on_refresh_success,
-                feature_flag_enabled=feature_flag_enabled,
             )
         if key_vault_options:
             if not key_vault_options.secret_resolver:
@@ -123,7 +117,6 @@ async def create_client(
                 user_agent="SDK/Integration",
                 key_vault_options=key_vault_options,
                 on_refresh_success=on_refresh_success,
-                feature_flag_enabled=feature_flag_enabled,
             )
         return await load(
             connection_string=appconfiguration_connection_string,
@@ -134,7 +127,6 @@ async def create_client(
             user_agent="SDK/Integration",
             secret_resolver=secret_resolver,
             on_refresh_success=on_refresh_success,
-            feature_flag_enabled=feature_flag_enabled,
         )