FeatureManagement 2.0.0b1__tar.gz → 2.0.0b2__tar.gz

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

@@ -1,5 +1,10 @@
 # Release History
 
+## 2.0.0b2 (10/11/2024)
+
+* Adds VariantAllocationPercentage, 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.0b2/FeatureManagement.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: FeatureManagement
-Version: 2.0.0b1
+Version: 2.0.0b2
 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.0b2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: FeatureManagement
-Version: 2.0.0b1
+Version: 2.0.0b2
 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.0b2}/featuremanagement/_featuremanagerbase.py

@@ -168,14 +168,17 @@ class FeatureManagerBase(ABC):
                 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:
+        if not variant_name and 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 feature.allocation.percentile:
+            seed = feature.allocation.seed
+            if not seed:
+                seed = "allocation\n" + feature.name
+            context_id = 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:

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

@@ -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.0b2}/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.0b2}/featuremanagement/_version.py

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

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

@@ -25,6 +25,8 @@ REASON = "VariantAssignmentReason"
 
 EVENT_NAME = "FeatureEvaluation"
 
+EVALUATION_EVENT_VERSION = "1.0.0"
+
 
 def track_event(event_name: str, user: str, event_properties: Optional[Dict[str, Optional[str]]] = None) -> None:
     """
@@ -51,17 +53,49 @@ 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: Dict[str, Optional[str]] = {}
+    if not evaluation_event.feature:
+        return
+    event[FEATURE_NAME] = evaluation_event.feature.name
     event[ENABLED] = str(evaluation_event.enabled)
+    event["Version"] = EVALUATION_EVENT_VERSION
 
+    # VariantAllocationPercentage
     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:
+        if evaluation_event.reason == VariantAssignmentReason.DEFAULT_WHEN_ENABLED:
+            allocation_percentage = 0
+
+            if evaluation_event.feature.allocation and evaluation_event.feature.allocation.percentile:
+                for allocation in evaluation_event.feature.allocation.percentile:
+                    if (
+                        evaluation_event.variant
+                        and allocation.variant == evaluation_event.variant.name
+                        and allocation.percentile_to
+                    ):
+                        allocation_percentage += allocation.percentile_to - allocation.percentile_from
+
+            event["VariantAssignmentPercentage"] = str(100 - allocation_percentage)
+        elif evaluation_event.reason == VariantAssignmentReason.PERCENTILE:
+            if evaluation_event.feature.allocation and evaluation_event.feature.allocation.percentile:
+                allocation_percentage = 0
+                for allocation in evaluation_event.feature.allocation.percentile:
+                    if (
+                        evaluation_event.variant
+                        and allocation.variant == evaluation_event.variant.name
+                        and allocation.percentile_to
+                    ):
+                        allocation_percentage += allocation.percentile_to - allocation.percentile_from
+                event["VariantAssignmentPercentage"] = str(allocation_percentage)
+
+    # DefaultWhenEnabled
+    if evaluation_event.feature.allocation and evaluation_event.feature.allocation.default_when_enabled:
+        event["DefaultWhenEnabled"] = evaluation_event.feature.allocation.default_when_enabled
+
+    if evaluation_event.feature.telemetry:
         for metadata_key, metadata_value in evaluation_event.feature.telemetry.metadata.items():
             if metadata_key not in event:
                 event[metadata_key] = metadata_value

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

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

{featuremanagement-2.0.0b1 → featuremanagement-2.0.0b2}/tests/test_feature_variants.py

@@ -112,6 +112,46 @@ class TestFeatureVariants:
         assert feature_manager.is_enabled("Alpha", "Charlie")
         assert feature_manager.get_variant("Alpha", "Charlie") is None
 
+    def test_user_and_group_allocation(self):
+        feature_flags = {
+            "feature_management": {
+                "feature_flags": [
+                    {
+                        "id": "Alpha",
+                        "enabled": True,
+                        "variants": [
+                            {"name": "Off", "status_override": "Enabled"},
+                            {"name": "On", "status_override": "Disabled"},
+                        ],
+                        "allocation": {
+                            "user": [{"variant": "On", "users": ["Adam"]}, {"variant": "Off", "users": ["Brittney"]}],
+                            "group": [
+                                {"variant": "On", "groups": ["Group1"]},
+                                {"variant": "Off", "groups": ["Group2"]},
+                            ],
+                        },
+                        "conditions": {
+                            "client_filters": [
+                                {
+                                    "name": "AlwaysOnFilter",
+                                    "parameters": {},
+                                }
+                            ]
+                        },
+                    }
+                ]
+            }
+        }
+        feature_manager = FeatureManager(feature_flags, feature_filters=[AlwaysOnFilter()])
+        assert feature_manager.is_enabled("Alpha")
+        assert feature_manager.get_variant("Alpha") is None
+        assert not feature_manager.is_enabled("Alpha", TargetingContext(user_id="NotAdam", groups=["Group1"]))
+        assert feature_manager.get_variant("Alpha", TargetingContext(user_id="NotAdam", groups=["Group1"])).name == "On"
+        assert not feature_manager.is_enabled("Alpha", TargetingContext(user_id="NotAdam", groups=["Group1"]))
+        assert feature_manager.get_variant("Alpha", TargetingContext(groups=["Group2"])).name == "Off"
+        assert feature_manager.is_enabled("Alpha", TargetingContext(user_id="NotCharlie", groups=["Group3"]))
+        assert feature_manager.get_variant("Alpha", TargetingContext(user_id="NotCharlie", groups=["Group3"])) is None
+
     # method: is_enabled
     def test_basic_feature_variant_allocation_groups(self):
         feature_flags = {