FeatureManagement 2.0.0b2__tar.gz → 2.0.0b3__tar.gz

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

@@ -1,8 +1,13 @@
 # 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 VariantAllocationPercentage, DefaultWhenEnabled, and AllocationId to telemetry.
+* 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)

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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: FeatureManagement
-Version: 2.0.0b2
+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.0b2 → 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.0b2 → 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,56 +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
-        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
-        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
+
+        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]:
         """
@@ -208,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)
@@ -225,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.0b2 → 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.
 

{featuremanagement-2.0.0b2 → 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.0b2 → featuremanagement-2.0.0b3}/featuremanagement/_version.py

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

{featuremanagement-2.0.0b2 → 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.0b3/featuremanagement/azuremonitor/_send_telemetry.py

@@ -0,0 +1,102 @@
+# -------------------------------------------------------------------------
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# Licensed under the MIT License. See License.txt in the project root for
+# license information.
+# --------------------------------------------------------------------------
+import logging
+from typing import Dict, Optional
+from .._models import VariantAssignmentReason, EvaluationEvent
+
+try:
+    from azure.monitor.events.extension import track_event as azure_monitor_track_event  # type: ignore
+
+    HAS_AZURE_MONITOR_EVENTS_EXTENSION = True
+except ImportError:
+    HAS_AZURE_MONITOR_EVENTS_EXTENSION = False
+    logging.warning(
+        "azure-monitor-events-extension is not installed. Telemetry will not be sent to Application Insights."
+    )
+
+FEATURE_NAME = "FeatureName"
+ENABLED = "Enabled"
+TARGETING_ID = "TargetingId"
+VARIANT = "Variant"
+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:
+    """
+    Tracks an event with the specified name and properties.
+
+    :param str event_name: The name of the event.
+    :param str user: The user ID to associate with the event.
+    :param dict[str, str] event_properties: A dictionary of named string properties.
+    """
+    if not HAS_AZURE_MONITOR_EVENTS_EXTENSION:
+        return
+
+    event_properties = event_properties or {}
+
+    if user:
+        event_properties[TARGETING_ID] = user
+
+    azure_monitor_track_event(event_name, event_properties)
+
+
+def publish_telemetry(evaluation_event: EvaluationEvent) -> None:
+    """
+    Publishes the telemetry for a feature's evaluation event.
+
+    :param EvaluationEvent evaluation_event: The evaluation event to publish telemetry for.
+    """
+    if not HAS_AZURE_MONITOR_EVENTS_EXTENSION:
+        return
+
+    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.0b2 → featuremanagement-2.0.0b3}/pyproject.toml

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

{featuremanagement-2.0.0b2 → 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):