FeatureManagement 2.0.0b1__tar.gz → 2.0.0b3__tar.gz

{featuremanagement-2.0.0b1 → featuremanagement-2.0.0b3}/CHANGELOG.md

@@ -1,5 +1,15 @@
 # Release History
 
+## 2.0.0b3 (11/14/2024)
+
+* Fixes a bug where no allocation reason is set if a user is allocated to exactly 100.
+* Fixes a bug where VariantAssignmentPercentage wasn't correct for default when enabled.
+
+## 2.0.0b2 (10/11/2024)
+
+* Adds VariantAssignmentPercentage, DefaultWhenEnabled, and AllocationId to telemetry.
+* Allocation seed value is now None by default, and only defaults to `allocation\n<feature.id>` when assigning variants.
+
 ## 2.0.0b1 (09/10/2024)
 
 * Adds support for Feature Variants.

{featuremanagement-2.0.0b1 → featuremanagement-2.0.0b3/FeatureManagement.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: FeatureManagement
-Version: 2.0.0b1
+Version: 2.0.0b3
 Summary: A library for enabling/disabling features at runtime.
 Home-page: https://github.com/Azure/azure-sdk-for-python/tree/main/sdk/appconfiguration/feature-management
 Author: Microsoft Corporation

{featuremanagement-2.0.0b1/FeatureManagement.egg-info → featuremanagement-2.0.0b3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: FeatureManagement
-Version: 2.0.0b1
+Version: 2.0.0b3
 Summary: A library for enabling/disabling features at runtime.
 Home-page: https://github.com/Azure/azure-sdk-for-python/tree/main/sdk/appconfiguration/feature-management
 Author: Microsoft Corporation

{featuremanagement-2.0.0b1 → featuremanagement-2.0.0b3}/featuremanagement/_featuremanager.py

@@ -3,16 +3,13 @@
 # Licensed under the MIT License. See License.txt in the project root for
 # license information.
 # -------------------------------------------------------------------------
-import logging
 from typing import cast, overload, Any, Optional, Dict, Mapping, List
 from ._defaultfilters import TimeWindowFilter, TargetingFilter
 from ._featurefilters import FeatureFilter
 from ._models import EvaluationEvent, Variant, TargetingContext
 from ._featuremanagerbase import (
-    _get_feature_flag,
     FeatureManagerBase,
     PROVIDED_FEATURE_FILTERS,
-    FEATURE_MANAGEMENT_KEY,
     REQUIREMENT_TYPE_ALL,
     FEATURE_FILTER_NAME,
 )
@@ -143,35 +140,13 @@ class FeatureManager(FeatureManagerBase):
         Determine if the feature flag is enabled for the given context.
 
         :param str feature_flag_id: Name of the feature flag.
-        :return: True if the feature flag is enabled for the given context.
-        :rtype: bool
+        :param TargetingContext targeting_context: Targeting context.
+        :return: EvaluationEvent for the given context.
+        :rtype: EvaluationEvent
         """
-        if self._copy is not self._configuration.get(FEATURE_MANAGEMENT_KEY):
-            self._cache = {}
-            self._copy = self._configuration.get(FEATURE_MANAGEMENT_KEY)
-
-        if not self._cache.get(feature_flag_id):
-            feature_flag = _get_feature_flag(self._configuration, feature_flag_id)
-            self._cache[feature_flag_id] = feature_flag
-        else:
-            feature_flag = self._cache.get(feature_flag_id)
-
-        evaluation_event = EvaluationEvent(feature_flag)
-        if not feature_flag:
-            logging.warning("Feature flag %s not found", feature_flag_id)
-            # Unknown feature flags are disabled by default
-            return evaluation_event
-
-        if not feature_flag.enabled:
-            # Feature flags that are disabled are always disabled
-            FeatureManager._check_default_disabled_variant(evaluation_event)
-            if feature_flag.allocation:
-                variant_name = feature_flag.allocation.default_when_disabled
-                evaluation_event.variant = self._variant_name_to_variant(feature_flag, variant_name)
-            evaluation_event.feature = feature_flag
+        evaluation_event, done = super()._check_feature_base(feature_flag_id)
 
-            # If a feature flag is disabled and override can't enable it
-            evaluation_event.enabled = False
+        if done:
             return evaluation_event
 
         self._check_feature_filters(evaluation_event, targeting_context, **kwargs)

{featuremanagement-2.0.0b1 → featuremanagement-2.0.0b3}/featuremanagement/_featuremanagerbase.py

@@ -4,6 +4,7 @@
 # license information.
 # -------------------------------------------------------------------------
 import hashlib
+import logging
 from abc import ABC
 from typing import List, Optional, Dict, Tuple, Any, Mapping
 from ._models import FeatureFlag, Variant, VariantAssignmentReason, TargetingContext, EvaluationEvent, VariantReference
@@ -78,7 +79,7 @@ class FeatureManagerBase(ABC):
         self._on_feature_evaluated = kwargs.pop("on_feature_evaluated", None)
 
     @staticmethod
-    def _check_default_disabled_variant(evaluation_event: EvaluationEvent) -> None:
+    def _assign_default_disabled_variant(evaluation_event: EvaluationEvent) -> None:
         """
         A method called when the feature flag is disabled, to determine what the default variant should be. If there is
         no allocation, then None is set as the value of the variant in the EvaluationEvent.
@@ -88,7 +89,7 @@ class FeatureManagerBase(ABC):
         evaluation_event.reason = VariantAssignmentReason.DEFAULT_WHEN_DISABLED
         if not evaluation_event.feature or not evaluation_event.feature.allocation:
             return
-        FeatureManagerBase._check_variant_override(
+        FeatureManagerBase._assign_variant_override(
             evaluation_event.feature.variants,
             evaluation_event.feature.allocation.default_when_disabled,
             False,
@@ -96,7 +97,7 @@ class FeatureManagerBase(ABC):
         )
 
     @staticmethod
-    def _check_default_enabled_variant(evaluation_event: EvaluationEvent) -> None:
+    def _assign_default_enabled_variant(evaluation_event: EvaluationEvent) -> None:
         """
         A method called when the feature flag is enabled, to determine what the default variant should be. If there is
         no allocation, then None is set as the value of the variant in the EvaluationEvent.
@@ -106,7 +107,7 @@ class FeatureManagerBase(ABC):
         evaluation_event.reason = VariantAssignmentReason.DEFAULT_WHEN_ENABLED
         if not evaluation_event.feature or not evaluation_event.feature.allocation:
             return
-        FeatureManagerBase._check_variant_override(
+        FeatureManagerBase._assign_variant_override(
             evaluation_event.feature.variants,
             evaluation_event.feature.allocation.default_when_enabled,
             True,
@@ -114,7 +115,7 @@ class FeatureManagerBase(ABC):
         )
 
     @staticmethod
-    def _check_variant_override(
+    def _assign_variant_override(
         variants: Optional[List[VariantReference]],
         default_variant_name: Optional[str],
         status: bool,
@@ -149,53 +150,57 @@ class FeatureManagerBase(ABC):
 
         return (context_marker / (2**32 - 1)) * 100
 
-    def _assign_variant(
-        self, feature_flag: FeatureFlag, targeting_context: TargetingContext, evaluation_event: EvaluationEvent
-    ) -> None:
+    def _assign_variant(self, targeting_context: TargetingContext, evaluation_event: EvaluationEvent) -> None:
         """
         Assign a variant to the user based on the allocation.
 
-        :param FeatureFlag feature_flag: Feature flag object.
         :param TargetingContext targeting_context: Targeting context.
         :param EvaluationEvent evaluation_event: Evaluation event object.
         """
-        feature = evaluation_event.feature
+        feature_flag = evaluation_event.feature
         variant_name = None
-        if not feature or not feature.variants or not feature.allocation:
+        if not feature_flag or not feature_flag.variants or not feature_flag.allocation:
             return
-        if feature.allocation.user and targeting_context.user_id:
-            for user_allocation in feature.allocation.user:
+
+        allocation = feature_flag.allocation
+        groups = targeting_context.groups
+
+        if allocation.user and targeting_context.user_id:
+            for user_allocation in allocation.user:
                 if targeting_context.user_id in user_allocation.users:
                     evaluation_event.reason = VariantAssignmentReason.USER
                     variant_name = user_allocation.variant
-        elif feature.allocation.group and len(targeting_context.groups) > 0:
-            for group_allocation in feature.allocation.group:
-                for group in targeting_context.groups:
-                    if group in group_allocation.groups:
-                        evaluation_event.reason = VariantAssignmentReason.GROUP
-                        variant_name = group_allocation.variant
-        elif feature.allocation.percentile:
-            context_id = targeting_context.user_id + "\n" + feature.allocation.seed
+
+        if not variant_name and allocation.group and groups:
+            for group_allocation in allocation.group:
+                if any(group in group_allocation.groups for group in groups):
+                    evaluation_event.reason = VariantAssignmentReason.GROUP
+                    variant_name = group_allocation.variant
+
+        if not variant_name and allocation.percentile:
+            seed = allocation.seed or f"allocation\n{feature_flag.name}"
+            context_id = f"{targeting_context.user_id}\n{seed}"
             box: float = self._is_targeted(context_id)
-            for percentile_allocation in feature.allocation.percentile:
-                if box == 100 and percentile_allocation.percentile_to == 100:
-                    variant_name = percentile_allocation.variant
-                if not percentile_allocation.percentile_to:
-                    continue
-                if percentile_allocation.percentile_from <= box < percentile_allocation.percentile_to:
+            for percentile_allocation in allocation.percentile:
+                percentile_to: int = percentile_allocation.percentile_to
+                if (box == 100 and percentile_to == 100) or (
+                    percentile_allocation.percentile_from <= box < percentile_to
+                ):
                     evaluation_event.reason = VariantAssignmentReason.PERCENTILE
                     variant_name = percentile_allocation.variant
+                    break
+
         if not variant_name:
-            FeatureManagerBase._check_default_enabled_variant(evaluation_event)
+            FeatureManagerBase._assign_default_enabled_variant(evaluation_event)
             if feature_flag.allocation:
                 evaluation_event.variant = self._variant_name_to_variant(
                     feature_flag, feature_flag.allocation.default_when_enabled
                 )
                 return
+
         evaluation_event.variant = self._variant_name_to_variant(feature_flag, variant_name)
-        if not feature_flag.variants:
-            return
-        FeatureManagerBase._check_variant_override(feature_flag.variants, variant_name, True, evaluation_event)
+        if feature_flag.variants:
+            FeatureManagerBase._assign_variant_override(feature_flag.variants, variant_name, True, evaluation_event)
 
     def _variant_name_to_variant(self, feature_flag: FeatureFlag, variant_name: Optional[str]) -> Optional[Variant]:
         """
@@ -205,10 +210,9 @@ class FeatureManagerBase(ABC):
         :param str variant_name: Name of the variant.
         :return: Variant object.
         """
-        if not feature_flag.variants:
-            return None
-        if not variant_name:
+        if not feature_flag.variants or not variant_name:
             return None
+
         for variant_reference in feature_flag.variants:
             if variant_reference.name == variant_name:
                 return Variant(variant_reference.name, variant_reference.configuration_value)
@@ -222,31 +226,66 @@ class FeatureManagerBase(ABC):
         :param args: Arguments to build the TargetingContext.
         :return: TargetingContext
         """
-        if len(args) == 1 and isinstance(args[0], str):
-            return TargetingContext(user_id=args[0], groups=[])
-        if len(args) == 1 and isinstance(args[0], TargetingContext):
-            return args[0]
+        if len(args) == 1:
+            arg = args[0]
+            if isinstance(arg, str):
+                return TargetingContext(user_id=arg, groups=[])
+            if isinstance(arg, TargetingContext):
+                return arg
         return TargetingContext()
 
     def _assign_allocation(self, evaluation_event: EvaluationEvent, targeting_context: TargetingContext) -> None:
         feature_flag = evaluation_event.feature
         if not feature_flag:
             return
-        if feature_flag.variants:
-            if not feature_flag.allocation:
-                if evaluation_event.enabled:
-                    evaluation_event.reason = VariantAssignmentReason.DEFAULT_WHEN_ENABLED
-                    return
-                evaluation_event.reason = VariantAssignmentReason.DEFAULT_WHEN_DISABLED
-                return
-            if not evaluation_event.enabled:
-                FeatureManagerBase._check_default_disabled_variant(evaluation_event)
-                evaluation_event.variant = self._variant_name_to_variant(
-                    feature_flag, feature_flag.allocation.default_when_disabled
-                )
-                return
 
-            self._assign_variant(feature_flag, targeting_context, evaluation_event)
+        if not feature_flag.variants or not feature_flag.allocation:
+            return
+
+        if not evaluation_event.enabled:
+            FeatureManagerBase._assign_default_disabled_variant(evaluation_event)
+            evaluation_event.variant = self._variant_name_to_variant(
+                feature_flag, feature_flag.allocation.default_when_disabled
+            )
+            return
+
+        self._assign_variant(targeting_context, evaluation_event)
+
+    def _check_feature_base(self, feature_flag_id: str) -> Tuple[EvaluationEvent, bool]:
+        """
+        Determine if the feature flag is enabled for the given context.
+
+        :param str feature_flag_id: Name of the feature flag.
+        :return: The evaluation event and if the feature filters need to be checked.
+        :rtype: evaluation_event, bool
+        """
+        if self._copy is not self._configuration.get(FEATURE_MANAGEMENT_KEY):
+            self._cache = {}
+            self._copy = self._configuration.get(FEATURE_MANAGEMENT_KEY)
+
+        if not self._cache.get(feature_flag_id):
+            feature_flag = _get_feature_flag(self._configuration, feature_flag_id)
+            self._cache[feature_flag_id] = feature_flag
+        else:
+            feature_flag = self._cache.get(feature_flag_id)
+
+        evaluation_event = EvaluationEvent(feature_flag)
+        if not feature_flag:
+            logging.warning("Feature flag %s not found", feature_flag_id)
+            # Unknown feature flags are disabled by default
+            return evaluation_event, True
+
+        if not feature_flag.enabled:
+            # Feature flags that are disabled are always disabled
+            self._assign_default_disabled_variant(evaluation_event)
+            if feature_flag.allocation:
+                variant_name = feature_flag.allocation.default_when_disabled
+                evaluation_event.variant = self._variant_name_to_variant(feature_flag, variant_name)
+
+            # If a feature flag is disabled and override can't enable it
+            evaluation_event.enabled = False
+            return evaluation_event, True
+        return evaluation_event, False
 
     def list_feature_flag_names(self) -> List[str]:
         """

{featuremanagement-2.0.0b1 → featuremanagement-2.0.0b3}/featuremanagement/_models/_allocation.py

@@ -36,7 +36,7 @@ class PercentileAllocation:
     def __init__(self) -> None:
         self._variant: Optional[str] = None
         self._percentile_from: int = 0
-        self._percentile_to: Optional[int] = None
+        self._percentile_to: int = 0
 
     @classmethod
     def convert_from_json(cls, json: Mapping[str, Union[str, int]]) -> "PercentileAllocation":
@@ -88,7 +88,7 @@ class PercentileAllocation:
         return self._percentile_from
 
     @property
-    def percentile_to(self) -> Optional[int]:
+    def percentile_to(self) -> int:
         """
         Get the ending percentile for the allocation.
 
@@ -103,16 +103,16 @@ class Allocation:
     Represents an allocation configuration for a feature flag.
     """
 
-    def __init__(self, feature_name: str) -> None:
+    def __init__(self) -> None:
         self._default_when_enabled = None
         self._default_when_disabled = None
         self._user: List[UserAllocation] = []
         self._group: List[GroupAllocation] = []
         self._percentile: List[PercentileAllocation] = []
-        self._seed = "allocation\n" + feature_name
+        self._seed = None
 
     @classmethod
-    def convert_from_json(cls, json: Dict[str, Any], feature_name: str) -> Optional["Allocation"]:
+    def convert_from_json(cls, json: Dict[str, Any]) -> Optional["Allocation"]:
         """
         Convert a JSON object to Allocation.
 
@@ -123,7 +123,7 @@ class Allocation:
         """
         if not json:
             return None
-        allocation = cls(feature_name)
+        allocation = cls()
         allocation._default_when_enabled = json.get(DEFAULT_WHEN_ENABLED)
         allocation._default_when_disabled = json.get(DEFAULT_WHEN_DISABLED)
         allocation._user = []
@@ -197,7 +197,7 @@ class Allocation:
         return self._percentile
 
     @property
-    def seed(self) -> str:
+    def seed(self) -> Optional[str]:
         """
         Get the seed for the allocation.
 

{featuremanagement-2.0.0b1 → featuremanagement-2.0.0b3}/featuremanagement/_models/_evaluation_event.py

@@ -24,4 +24,4 @@ class EvaluationEvent:
         self.user = ""
         self.enabled = False
         self.variant: Optional[Variant] = None
-        self.reason: Optional[VariantAssignmentReason] = None
+        self.reason: VariantAssignmentReason = VariantAssignmentReason.NONE

{featuremanagement-2.0.0b1 → featuremanagement-2.0.0b3}/featuremanagement/_models/_feature_flag.py

@@ -51,9 +51,7 @@ class FeatureFlag:
             )
         else:
             feature_flag._conditions = FeatureConditions()
-        feature_flag._allocation = Allocation.convert_from_json(
-            json_value.get(FEATURE_FLAG_ALLOCATION, None), feature_flag._id
-        )
+        feature_flag._allocation = Allocation.convert_from_json(json_value.get(FEATURE_FLAG_ALLOCATION, None))
         if FEATURE_FLAG_VARIANTS in json_value:
             variants: List[Mapping[str, Any]] = json_value.get(FEATURE_FLAG_VARIANTS, [])
             feature_flag._variants = []
@@ -66,7 +64,7 @@ class FeatureFlag:
         return feature_flag
 
     @property
-    def name(self) -> Optional[str]:
+    def name(self) -> str:
         """
         Get the name of the feature flag.
 

{featuremanagement-2.0.0b1 → featuremanagement-2.0.0b3}/featuremanagement/_version.py

@@ -4,4 +4,4 @@
 # license information.
 # -------------------------------------------------------------------------
 
-VERSION = "2.0.0b1"
+VERSION = "2.0.0b3"

{featuremanagement-2.0.0b1 → featuremanagement-2.0.0b3}/featuremanagement/aio/_featuremanager.py

@@ -4,16 +4,13 @@
 # license information.
 # -------------------------------------------------------------------------
 import inspect
-import logging
-from typing import cast, overload, Mapping, Dict, Any, Optional, List
+from typing import cast, overload, Any, Optional, Dict, Mapping, List
 from ._defaultfilters import TimeWindowFilter, TargetingFilter
 from ._featurefilters import FeatureFilter
-from .._models import EvaluationEvent, TargetingContext, Variant
+from .._models import EvaluationEvent, Variant, TargetingContext
 from .._featuremanagerbase import (
-    _get_feature_flag,
     FeatureManagerBase,
     PROVIDED_FEATURE_FILTERS,
-    FEATURE_MANAGEMENT_KEY,
     REQUIREMENT_TYPE_ALL,
     FEATURE_FILTER_NAME,
 )
@@ -63,11 +60,16 @@ class FeatureManager(FeatureManagerBase):
         targeting_context = self._build_targeting_context(args)
 
         result = await self._check_feature(feature_flag_id, targeting_context, **kwargs)
-        if self._on_feature_evaluated and result.feature and result.feature.telemetry.enabled:
+        if (
+            self._on_feature_evaluated
+            and result.feature
+            and result.feature.telemetry.enabled
+            and callable(self._on_feature_evaluated)
+        ):
             result.user = targeting_context.user_id
             if inspect.iscoroutinefunction(self._on_feature_evaluated):
                 await self._on_feature_evaluated(result)
-            elif callable(self._on_feature_evaluated):
+            else:
                 self._on_feature_evaluated(result)
         return result.enabled
 
@@ -94,11 +96,16 @@ class FeatureManager(FeatureManagerBase):
         targeting_context = self._build_targeting_context(args)
 
         result = await self._check_feature(feature_flag_id, targeting_context, **kwargs)
-        if self._on_feature_evaluated and result.feature and result.feature.telemetry.enabled:
+        if (
+            self._on_feature_evaluated
+            and result.feature
+            and result.feature.telemetry.enabled
+            and callable(self._on_feature_evaluated)
+        ):
             result.user = targeting_context.user_id
             if inspect.iscoroutinefunction(self._on_feature_evaluated):
                 await self._on_feature_evaluated(result)
-            elif callable(self._on_feature_evaluated):
+            else:
                 self._on_feature_evaluated(result)
         return result.variant
 
@@ -141,35 +148,12 @@ class FeatureManager(FeatureManagerBase):
 
         :param str feature_flag_id: Name of the feature flag.
         :param TargetingContext targeting_context: Targeting context.
-        :return: True if the feature flag is enabled for the given context.
-        :rtype: bool
+        :return: EvaluationEvent for the given context.
+        :rtype: EvaluationEvent
         """
-        if self._copy is not self._configuration.get(FEATURE_MANAGEMENT_KEY):
-            self._cache = {}
-            self._copy = self._configuration.get(FEATURE_MANAGEMENT_KEY)
-
-        if not self._cache.get(feature_flag_id):
-            feature_flag = _get_feature_flag(self._configuration, feature_flag_id)
-            self._cache[feature_flag_id] = feature_flag
-        else:
-            feature_flag = self._cache.get(feature_flag_id)
-
-        evaluation_event = EvaluationEvent(feature_flag)
-        if not feature_flag:
-            logging.warning("Feature flag %s not found", feature_flag_id)
-            # Unknown feature flags are disabled by default
-            return evaluation_event
-
-        if not feature_flag.enabled:
-            # Feature flags that are disabled are always disabled
-            FeatureManager._check_default_disabled_variant(evaluation_event)
-            if feature_flag.allocation:
-                variant_name = feature_flag.allocation.default_when_disabled
-                evaluation_event.variant = self._variant_name_to_variant(feature_flag, variant_name)
-            evaluation_event.feature = feature_flag
+        evaluation_event, done = super()._check_feature_base(feature_flag_id)
 
-            # If a feature flag is disabled and override can't enable it
-            evaluation_event.enabled = False
+        if done:
             return evaluation_event
 
         await self._check_feature_filters(evaluation_event, targeting_context, **kwargs)

{featuremanagement-2.0.0b1 → featuremanagement-2.0.0b3}/featuremanagement/azuremonitor/_send_telemetry.py

@@ -25,6 +25,8 @@ REASON = "VariantAssignmentReason"
 
 EVENT_NAME = "FeatureEvaluation"
 
+EVALUATION_EVENT_VERSION = "1.1.0"
+
 
 def track_event(event_name: str, user: str, event_properties: Optional[Dict[str, Optional[str]]] = None) -> None:
     """
@@ -36,10 +38,12 @@ def track_event(event_name: str, user: str, event_properties: Optional[Dict[str,
     """
     if not HAS_AZURE_MONITOR_EVENTS_EXTENSION:
         return
-    if event_properties is None:
-        event_properties = {}
+
+    event_properties = event_properties or {}
+
     if user:
         event_properties[TARGETING_ID] = user
+
     azure_monitor_track_event(event_name, event_properties)
 
 
@@ -51,18 +55,48 @@ def publish_telemetry(evaluation_event: EvaluationEvent) -> None:
     """
     if not HAS_AZURE_MONITOR_EVENTS_EXTENSION:
         return
-    event = {}
-    if evaluation_event.feature:
-        event[FEATURE_NAME] = evaluation_event.feature.name
-    event[ENABLED] = str(evaluation_event.enabled)
-
-    if evaluation_event.reason and evaluation_event.reason != VariantAssignmentReason.NONE:
-        if evaluation_event.variant:
-            event[VARIANT] = evaluation_event.variant.name
-        event[REASON] = evaluation_event.reason.value
-
-    if evaluation_event.feature and evaluation_event.feature.telemetry:
-        for metadata_key, metadata_value in evaluation_event.feature.telemetry.metadata.items():
+
+    feature = evaluation_event.feature
+
+    if not feature:
+        return
+
+    event: Dict[str, Optional[str]] = {
+        FEATURE_NAME: feature.name,
+        ENABLED: str(evaluation_event.enabled),
+        "Version": EVALUATION_EVENT_VERSION,
+    }
+
+    reason = evaluation_event.reason
+    variant = evaluation_event.variant
+
+    event[REASON] = reason.value
+
+    if variant:
+        event[VARIANT] = variant.name
+
+    # VariantAllocationPercentage
+    allocation_percentage = 0
+    if reason == VariantAssignmentReason.DEFAULT_WHEN_ENABLED:
+        event["VariantAssignmentPercentage"] = str(100)
+        if feature.allocation:
+            for allocation in feature.allocation.percentile:
+                allocation_percentage += allocation.percentile_to - allocation.percentile_from
+            event["VariantAssignmentPercentage"] = str(100 - allocation_percentage)
+    elif reason == VariantAssignmentReason.PERCENTILE:
+        if feature.allocation and feature.allocation.percentile:
+            for allocation in feature.allocation.percentile:
+                if variant and allocation.variant == variant.name:
+                    allocation_percentage += allocation.percentile_to - allocation.percentile_from
+            event["VariantAssignmentPercentage"] = str(allocation_percentage)
+
+    # DefaultWhenEnabled
+    if feature.allocation and feature.allocation.default_when_enabled:
+        event["DefaultWhenEnabled"] = feature.allocation.default_when_enabled
+
+    if feature.telemetry:
+        for metadata_key, metadata_value in feature.telemetry.metadata.items():
             if metadata_key not in event:
                 event[metadata_key] = metadata_value
+
     track_event(EVENT_NAME, evaluation_event.user, event_properties=event)

{featuremanagement-2.0.0b1 → featuremanagement-2.0.0b3}/pyproject.toml

@@ -19,7 +19,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "FeatureManagement"
-version = "2.0.0b1"
+version = "2.0.0b3"
 authors = [
   { name="Microsoft Corporation", email="appconfig@microsoft.com" },
 ]

{featuremanagement-2.0.0b1 → featuremanagement-2.0.0b3}/tests/test_feature_manager.py

@@ -3,11 +3,17 @@
 # Licensed under the MIT License. See License.txt in the project root for
 # license information.
 # --------------------------------------------------------------------------
+import unittest
 import pytest
 from featuremanagement import FeatureManager, FeatureFilter
 
 
-class TestFeatureManager:
+class TestFeatureManager(unittest.TestCase):
+
+    def __init__(self, methodName="runTest"):
+        super().__init__(methodName=methodName)
+        self.called_telemetry = False
+
     # method: feature_manager_creation
     def test_empty_feature_manager_creation(self):
         feature_manager = FeatureManager({})
@@ -29,6 +35,12 @@ class TestFeatureManager:
         assert feature_manager.is_enabled("Alpha")
         assert not feature_manager.is_enabled("Beta")
 
+    # method: feature_manager_creation
+    def test_feature_manager_creation_invalid_feature_filter(self):
+        feature_flags = {"feature_management": {"feature_flags": []}}
+        with self.assertRaises(ValueError):
+            FeatureManager(feature_flags, feature_filters=["invalid_filter"])
+
     # method: feature_manager_creation
     def test_feature_manager_creation_with_filters(self):
         feature_flags = {
@@ -119,6 +131,25 @@ class TestFeatureManager:
         assert e_info.type == ValueError
         assert e_info.value.args[0] == "Feature flag Alpha has unknown filter UnknownFilter"
 
+    # method: feature_manager_creation
+    def test_feature_with_telemetry(self):
+        self.called_telemetry = False
+        feature_flags = {
+            "feature_management": {
+                "feature_flags": [
+                    {"id": "Alpha", "description": "", "enabled": "true", "telemetry": {"enabled": "true"}},
+                ]
+            }
+        }
+        feature_manager = FeatureManager(feature_flags, on_feature_evaluated=self.fake_telemetry_callback)
+        assert feature_manager is not None
+        assert feature_manager.is_enabled("Alpha")
+        assert self.called_telemetry
+
+    def fake_telemetry_callback(self, evaluation_event):
+        assert evaluation_event
+        self.called_telemetry = True
+
 
 class AlwaysOn(FeatureFilter):
     def evaluate(self, context, **kwargs):