From b6ed6a1a3f1d3945e585c09011cb4a1c4b16bbb3 Mon Sep 17 00:00:00 2001 From: Andrew Helsby Date: Wed, 6 Jul 2022 11:18:39 +0400 Subject: [PATCH 01/10] hooks: Implementation of hooks for python Open Feature Signed-off-by: Andrew Helsby --- open_feature/hooks/__init__.py | 0 open_feature/hooks/hook.py | 62 ++++++++++++++++++++++++++++++ open_feature/hooks/hook_context.py | 19 +++++++++ open_feature/hooks/hook_support.py | 44 +++++++++++++++++++++ 4 files changed, 125 insertions(+) create mode 100644 open_feature/hooks/__init__.py create mode 100644 open_feature/hooks/hook.py create mode 100644 open_feature/hooks/hook_context.py create mode 100644 open_feature/hooks/hook_support.py diff --git a/open_feature/hooks/__init__.py b/open_feature/hooks/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/open_feature/hooks/hook.py b/open_feature/hooks/hook.py new file mode 100644 index 00000000..029db4bf --- /dev/null +++ b/open_feature/hooks/hook.py @@ -0,0 +1,62 @@ +from abc import abstractmethod + +from open_feature.flag_evaluation.flag_evaluation_details import FlagEvaluationDetails +from open_feature.flag_evaluation.flag_type import FlagType + + +class Hook: + @abstractmethod + def before(self, ctx, hints: dict): + """ + Runs before flag is resolved. + + :param ctx: Information about the particular flag evaluation + :param hints: An immutable mapping of data for users to + communicate to the hooks. + :return: An optional EvaluationContext. If returned, it will + be merged with the EvaluationContext instances from other + hooks, the client and API. + """ + pass + + @abstractmethod + def after(self, ctx, details: FlagEvaluationDetails, hints: dict): + """ + Runs after a flag is resolved. + + :param ctx: Information about the particular flag evaluation + :param details: Information about how the flag was resolved, + including any resolved values. + :param hints: An immutable mapping of data for users to + communicate to the hooks. + """ + pass + + @abstractmethod + def error(self, ctx, exception: Exception, hints: dict): + """ + Run when evaluation encounters an error. This will always run. + Errors thrown will be swallowed. + + :param ctx: Information about the particular flag evaluation + :param exception: + :param hints: An immutable mapping of data for users to + communicate to the hooks. + """ + pass + + @abstractmethod + def finally_after(self, ctx, hints: dict): + """ + Run after flag evaluation, including any error processing. + This will always run. Errors will be swallowed. + + :param ctx: Information about the particular flag evaluation + :param hints: An immutable mapping of data for users to + communicate to the hooks. + """ + pass + + @abstractmethod + def supports_flag_value_type(self, flag_type: FlagType) -> bool: + return True diff --git a/open_feature/hooks/hook_context.py b/open_feature/hooks/hook_context.py new file mode 100644 index 00000000..4ab07ec4 --- /dev/null +++ b/open_feature/hooks/hook_context.py @@ -0,0 +1,19 @@ +from open_feature.flag_evaluation.flag_type import FlagType + + +class HookContext: + def __init__( # noqa: CFQ002 + self, + flag_key: str, + flag_type: FlagType, + default_value, + ctx, + client_metadata=None, + provider_metadata=None, + ): + self.flag_key = flag_key + self.flag_type = flag_type + self.default_value = default_value + self.ctx = ctx + self.client_metadata = client_metadata + self.provider_metadata = provider_metadata diff --git a/open_feature/hooks/hook_support.py b/open_feature/hooks/hook_support.py new file mode 100644 index 00000000..26113db8 --- /dev/null +++ b/open_feature/hooks/hook_support.py @@ -0,0 +1,44 @@ +from open_feature.flag_evaluation.flag_evaluation_details import FlagEvaluationDetails +from open_feature.flag_evaluation.flag_type import FlagType +from open_feature.hooks.hook import Hook +from open_feature.hooks.hook_context import HookContext + + +def error_hooks( + flag_type: FlagType, + hook_context: HookContext, + exception: Exception, + hooks: list, + hints: dict, +): + execute_hooks(flag_type, hooks, "error", Hook.error(hook_context, exception, hints)) + + +def after_all_hooks( + flag_type: FlagType, hook_context: HookContext, hooks: list, hints: dict +): + execute_hooks(flag_type, hooks, "finally", Hook.finally_after(hook_context, hints)) + + +def after_hooks( + flag_type: FlagType, + hook_context: HookContext, + details: FlagEvaluationDetails, + hooks: list, + hints: dict, +): + execute_hooks_unchecked(flag_type, hooks, Hook.after(hook_context, details, hints)) + + +def before_hooks( + flag_type: FlagType, hook_context: HookContext, hooks: list, hints: dict +): + pass + + +def execute_hooks(flag_type: FlagType, hooks: list, hook_method: str, param1): + pass + + +def execute_hooks_unchecked(flag_type, hooks, param): + pass From 4011edb81d7885a755735a34343bd2a82daafed4 Mon Sep 17 00:00:00 2001 From: Andrew Helsby Date: Mon, 22 Aug 2022 10:06:51 +0200 Subject: [PATCH 02/10] hooks: Fix tests broken as a result of providing hook support Signed-off-by: Andrew Helsby --- open_feature/hooks/hook.py | 20 +++++--- open_feature/hooks/hook_context.py | 5 +- open_feature/hooks/hook_support.py | 68 ++++++++++++++++++++----- open_feature/open_feature_api.py | 14 +++++ open_feature/open_feature_client.py | 61 +++++++++++++++++++--- open_feature/provider/no_op_provider.py | 9 ++-- open_feature/provider/provider.py | 10 ++-- tests/hooks/__init__.py | 0 tests/hooks/conftest.py | 27 ++++++++++ tests/hooks/test_hook_support.py | 19 +++++++ 10 files changed, 197 insertions(+), 36 deletions(-) create mode 100644 tests/hooks/__init__.py create mode 100644 tests/hooks/conftest.py create mode 100644 tests/hooks/test_hook_support.py diff --git a/open_feature/hooks/hook.py b/open_feature/hooks/hook.py index 029db4bf..c6d959e7 100644 --- a/open_feature/hooks/hook.py +++ b/open_feature/hooks/hook.py @@ -1,16 +1,18 @@ from abc import abstractmethod +from open_feature.evaluation_context.evaluation_context import EvaluationContext from open_feature.flag_evaluation.flag_evaluation_details import FlagEvaluationDetails from open_feature.flag_evaluation.flag_type import FlagType +from open_feature.hooks.hook_context import HookContext class Hook: @abstractmethod - def before(self, ctx, hints: dict): + def before(self, hook_context: HookContext, hints: dict) -> EvaluationContext: """ Runs before flag is resolved. - :param ctx: Information about the particular flag evaluation + :param hook_context: Information about the particular flag evaluation :param hints: An immutable mapping of data for users to communicate to the hooks. :return: An optional EvaluationContext. If returned, it will @@ -20,11 +22,13 @@ def before(self, ctx, hints: dict): pass @abstractmethod - def after(self, ctx, details: FlagEvaluationDetails, hints: dict): + def after( + self, hook_context: HookContext, details: FlagEvaluationDetails, hints: dict + ): """ Runs after a flag is resolved. - :param ctx: Information about the particular flag evaluation + :param hook_context: Information about the particular flag evaluation :param details: Information about how the flag was resolved, including any resolved values. :param hints: An immutable mapping of data for users to @@ -33,12 +37,12 @@ def after(self, ctx, details: FlagEvaluationDetails, hints: dict): pass @abstractmethod - def error(self, ctx, exception: Exception, hints: dict): + def error(self, hook_context: HookContext, exception: Exception, hints: dict): """ Run when evaluation encounters an error. This will always run. Errors thrown will be swallowed. - :param ctx: Information about the particular flag evaluation + :param hook_context: Information about the particular flag evaluation :param exception: :param hints: An immutable mapping of data for users to communicate to the hooks. @@ -46,12 +50,12 @@ def error(self, ctx, exception: Exception, hints: dict): pass @abstractmethod - def finally_after(self, ctx, hints: dict): + def finally_after(self, hook_context: HookContext, hints: dict): """ Run after flag evaluation, including any error processing. This will always run. Errors will be swallowed. - :param ctx: Information about the particular flag evaluation + :param hook_context: Information about the particular flag evaluation :param hints: An immutable mapping of data for users to communicate to the hooks. """ diff --git a/open_feature/hooks/hook_context.py b/open_feature/hooks/hook_context.py index 4ab07ec4..79eff1fc 100644 --- a/open_feature/hooks/hook_context.py +++ b/open_feature/hooks/hook_context.py @@ -1,3 +1,4 @@ +from open_feature.evaluation_context.evaluation_context import EvaluationContext from open_feature.flag_evaluation.flag_type import FlagType @@ -7,13 +8,13 @@ def __init__( # noqa: CFQ002 flag_key: str, flag_type: FlagType, default_value, - ctx, + evaluation_context: EvaluationContext, client_metadata=None, provider_metadata=None, ): self.flag_key = flag_key self.flag_type = flag_type self.default_value = default_value - self.ctx = ctx + self.evaluation_context = evaluation_context self.client_metadata = client_metadata self.provider_metadata = provider_metadata diff --git a/open_feature/hooks/hook_support.py b/open_feature/hooks/hook_support.py index 26113db8..748eac17 100644 --- a/open_feature/hooks/hook_support.py +++ b/open_feature/hooks/hook_support.py @@ -1,3 +1,7 @@ +import logging +from functools import reduce + +from open_feature.evaluation_context.evaluation_context import EvaluationContext from open_feature.flag_evaluation.flag_evaluation_details import FlagEvaluationDetails from open_feature.flag_evaluation.flag_type import FlagType from open_feature.hooks.hook import Hook @@ -8,37 +12,77 @@ def error_hooks( flag_type: FlagType, hook_context: HookContext, exception: Exception, - hooks: list, + hooks: list[Hook], hints: dict, ): - execute_hooks(flag_type, hooks, "error", Hook.error(hook_context, exception, hints)) + kwargs = {"ctx": hook_context, "exception": exception, "hints": hints} + execute_hooks(flag_type=flag_type, hooks=hooks, hook_method="error", **kwargs) def after_all_hooks( flag_type: FlagType, hook_context: HookContext, hooks: list, hints: dict ): - execute_hooks(flag_type, hooks, "finally", Hook.finally_after(hook_context, hints)) + kwargs = {"ctx": hook_context, "hints": hints} + execute_hooks( + flag_type=flag_type, hooks=hooks, hook_method="finally_after", **kwargs + ) def after_hooks( flag_type: FlagType, hook_context: HookContext, details: FlagEvaluationDetails, - hooks: list, + hooks: list[Hook], hints: dict, ): - execute_hooks_unchecked(flag_type, hooks, Hook.after(hook_context, details, hints)) + kwargs = {"ctx": hook_context, "details": details, "hints": hints} + execute_hooks_unchecked( + flag_type=flag_type, hooks=hooks, hook_method="after", **kwargs + ) def before_hooks( - flag_type: FlagType, hook_context: HookContext, hooks: list, hints: dict -): - pass + flag_type: FlagType, hook_context: HookContext, hooks: list[Hook], hints: dict +) -> EvaluationContext: + kwargs = {"ctx": hook_context, "hints": hints} + executed_hooks = execute_hooks( + flag_type=flag_type, hooks=hooks, hook_method="before", **kwargs + ) + filtered_hooks = list(filter(lambda hook: hook is None, executed_hooks)) + + if filtered_hooks: + return reduce(lambda a, b: a.merge(b), filtered_hooks) + else: + return EvaluationContext() + + +def execute_hooks( + flag_type: FlagType, hooks: list[Hook], hook_method: str, **kwargs +) -> list: + if hooks: + filtered_hooks = list( + filter( + lambda hook: hook.supports_flag_value_type(flag_type=flag_type), hooks + ) + ) + return [execute_checked(hook, hook_method, **kwargs) for hook in filtered_hooks] + return [] -def execute_hooks(flag_type: FlagType, hooks: list, hook_method: str, param1): - pass +def execute_hooks_unchecked( + flag_type: FlagType, hooks, hook_method: str, **kwargs +) -> list: + if hooks: + filtered_hooks = list( + filter( + lambda hook: hook.supports_flag_value_type(flag_type=flag_type), hooks + ) + ) + return [getattr(hook, hook_method)(**kwargs) for hook in filtered_hooks] -def execute_hooks_unchecked(flag_type, hooks, param): - pass +def execute_checked(hook: Hook, hook_method: str, **kwargs): + try: + getattr(hook, hook_method)(**kwargs) + except Exception: + logging.error(f"Exception when running {hook_method} hooks") diff --git a/open_feature/open_feature_api.py b/open_feature/open_feature_api.py index 60c3f3d2..76448126 100644 --- a/open_feature/open_feature_api.py +++ b/open_feature/open_feature_api.py @@ -1,10 +1,12 @@ import typing +from open_feature.evaluation_context.evaluation_context import EvaluationContext from open_feature.exception.exceptions import GeneralError from open_feature.open_feature_client import OpenFeatureClient from open_feature.provider.provider import AbstractProvider _provider = None +_evaluation_context = None def get_client(name: str = None, version: str = None) -> OpenFeatureClient: @@ -25,3 +27,15 @@ def set_provider(provider: AbstractProvider): def get_provider() -> typing.Optional[AbstractProvider]: global _provider return _provider + + +def get_evaluation_context() -> EvaluationContext: + global _evaluation_context + return _evaluation_context + + +def set_evaluation_context(evaluation_context: EvaluationContext): + global _evaluation_context + if evaluation_context is None: + raise GeneralError(error_message="No api level evaluation context") + _evaluation_context = evaluation_context diff --git a/open_feature/open_feature_client.py b/open_feature/open_feature_client.py index c9ff7d66..1598a5e2 100644 --- a/open_feature/open_feature_client.py +++ b/open_feature/open_feature_client.py @@ -6,6 +6,14 @@ from open_feature.flag_evaluation.flag_evaluation_details import FlagEvaluationDetails from open_feature.flag_evaluation.flag_type import FlagType from open_feature.flag_evaluation.reason import Reason +from open_feature.hooks.hook import Hook +from open_feature.hooks.hook_context import HookContext +from open_feature.hooks.hook_support import ( + after_all_hooks, + after_hooks, + before_hooks, + error_hooks, +) from open_feature.provider.provider import AbstractProvider @@ -14,8 +22,8 @@ def __init__( self, name: str, version: str, - context=None, - hooks: list = None, + context: EvaluationContext = EvaluationContext(), + hooks: list[Hook] = None, provider: AbstractProvider = None, ): self.name = name @@ -24,6 +32,9 @@ def __init__( self.hooks = hooks or [] self.provider = provider + def add_hooks(self, hooks: list[Hook]): + self.hooks = self.hooks + hooks + def get_boolean_value( self, key: str, @@ -152,20 +163,55 @@ def evaluate_flag_details( evaluation_context: EvaluationContext = None, flag_evaluation_options: typing.Any = None, ) -> FlagEvaluationDetails: + """ + + :param flag_type: + :param key: + :param default_value: + :param evaluation_context: + :param flag_evaluation_options: + :return: + """ + if evaluation_context is None: evaluation_context = EvaluationContext() + + hook_context = HookContext( + flag_key=key, + flag_type=flag_type, + default_value=default_value, + evaluation_context=evaluation_context, + client_metadata=None, + provider_metadata=None, + ) + merged_hooks = [] + try: - # The merge below will eventually pull in Evaluation contexts from Hooks - invocation_context = EvaluationContext() + invocation_context = before_hooks( + flag_type, hook_context, merged_hooks, None + ) invocation_context.merge(ctx2=evaluation_context) - return self.create_provider_evaluation( + + merged_context = ( + # Todo pull the evaluation context below from api + EvaluationContext() + .merge(self.context) + .merge(invocation_context) + ) + + flag_evaluation = self.create_provider_evaluation( flag_type, key, default_value, - invocation_context, + merged_context, flag_evaluation_options, ) + + after_hooks(type, hook_context, flag_evaluation, merged_hooks, None) + + return flag_evaluation except OpenFeatureError as ofe: + error_hooks(flag_type, hook_context, merged_hooks, None) return FlagEvaluationDetails( key=key, value=default_value, @@ -173,6 +219,9 @@ def evaluate_flag_details( error_code=ofe.error_message, ) + finally: + after_all_hooks(flag_type, hook_context, merged_hooks, None) + def create_provider_evaluation( self, flag_type: FlagType, diff --git a/open_feature/provider/no_op_provider.py b/open_feature/provider/no_op_provider.py index e9fe1a42..93518b6d 100644 --- a/open_feature/provider/no_op_provider.py +++ b/open_feature/provider/no_op_provider.py @@ -1,6 +1,7 @@ import typing from numbers import Number +from open_feature.evaluation_context.evaluation_context import EvaluationContext from open_feature.flag_evaluation.flag_evaluation_details import FlagEvaluationDetails from open_feature.flag_evaluation.reason import Reason from open_feature.provider.provider import AbstractProvider @@ -16,7 +17,7 @@ def get_boolean_details( self, key: str, default_value: bool, - evaluation_context: typing.Any = None, + evaluation_context: EvaluationContext = EvaluationContext(), flag_evaluation_options: typing.Any = None, ): return FlagEvaluationDetails( @@ -30,7 +31,7 @@ def get_string_details( self, key: str, default_value: str, - evaluation_context: typing.Any = None, + evaluation_context: EvaluationContext = EvaluationContext(), flag_evaluation_options: typing.Any = None, ): return FlagEvaluationDetails( @@ -44,7 +45,7 @@ def get_number_details( self, key: str, default_value: Number, - evaluation_context: typing.Any = None, + evaluation_context: EvaluationContext = EvaluationContext(), flag_evaluation_options: typing.Any = None, ): return FlagEvaluationDetails( @@ -58,7 +59,7 @@ def get_object_details( self, key: str, default_value: dict, - evaluation_context: typing.Any = None, + evaluation_context: EvaluationContext = EvaluationContext(), flag_evaluation_options: typing.Any = None, ): return FlagEvaluationDetails( diff --git a/open_feature/provider/provider.py b/open_feature/provider/provider.py index 78390090..21421038 100644 --- a/open_feature/provider/provider.py +++ b/open_feature/provider/provider.py @@ -2,6 +2,8 @@ from abc import abstractmethod from numbers import Number +from open_feature.evaluation_context.evaluation_context import EvaluationContext + class AbstractProvider: @abstractmethod @@ -13,7 +15,7 @@ def get_boolean_details( self, key: str, default_value: bool, - evaluation_context: typing.Any = None, + evaluation_context: EvaluationContext = EvaluationContext(), flag_evaluation_options: typing.Any = None, ): pass @@ -23,7 +25,7 @@ def get_string_details( self, key: str, default_value: str, - evaluation_context: typing.Any = None, + evaluation_context: EvaluationContext = EvaluationContext(), flag_evaluation_options: typing.Any = None, ): pass @@ -33,7 +35,7 @@ def get_number_details( self, key: str, default_value: Number, - evaluation_context: typing.Any = None, + evaluation_context: EvaluationContext = EvaluationContext(), flag_evaluation_options: typing.Any = None, ): pass @@ -43,7 +45,7 @@ def get_object_details( self, key: str, default_value: dict, - evaluation_context: typing.Any = None, + evaluation_context: EvaluationContext = EvaluationContext(), flag_evaluation_options: typing.Any = None, ): pass diff --git a/tests/hooks/__init__.py b/tests/hooks/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/tests/hooks/conftest.py b/tests/hooks/conftest.py new file mode 100644 index 00000000..995bbeb8 --- /dev/null +++ b/tests/hooks/conftest.py @@ -0,0 +1,27 @@ +import pytest + +from open_feature.flag_evaluation.flag_evaluation_details import FlagEvaluationDetails +from open_feature.flag_evaluation.flag_type import FlagType +from open_feature.hooks.hook import Hook + + +class TestHook(Hook): + def before(self, ctx, hints: dict): + pass + + def after(self, ctx, details: FlagEvaluationDetails, hints: dict): + pass + + def error(self, ctx, exception: Exception, hints: dict): + return "Error" + + def finally_after(self, ctx, hints: dict): + pass + + def supports_flag_value_type(self, flag_type: FlagType) -> bool: + return True + + +@pytest.fixture() +def test_hook(): + return TestHook() diff --git a/tests/hooks/test_hook_support.py b/tests/hooks/test_hook_support.py new file mode 100644 index 00000000..defa51b6 --- /dev/null +++ b/tests/hooks/test_hook_support.py @@ -0,0 +1,19 @@ +from open_feature.flag_evaluation.flag_type import FlagType +from open_feature.hooks.hook import Hook +from open_feature.hooks.hook_context import HookContext +from open_feature.hooks.hook_support import error_hooks +from tests.hooks.conftest import TestHook + + +def setup(): + test_hook = TestHook() + assert isinstance(test_hook, Hook) + + +def test_error_hooks_run_error_method(test_hook): + # Given + hook_context = HookContext("flag_key", FlagType.BOOLEAN, True, "") + # When + error_hooks(FlagType.BOOLEAN, hook_context, Exception, [test_hook], {}) + # Then + assert True From bae40f5d2c6fceb528e4b5385df87118f1b51007 Mon Sep 17 00:00:00 2001 From: Andrew Helsby Date: Mon, 22 Aug 2022 15:57:47 +0200 Subject: [PATCH 03/10] hooks: Add api level evaluation context support Signed-off-by: Andrew Helsby --- open_feature/open_feature_api.py | 14 +---- open_feature/open_feature_client.py | 6 +-- .../open_feature_evaluation_context.py | 16 ++++++ tests/hooks/conftest.py | 33 ++++-------- tests/hooks/test_hook_support.py | 53 +++++++++++++++---- 5 files changed, 74 insertions(+), 48 deletions(-) create mode 100644 open_feature/open_feature_evaluation_context.py diff --git a/open_feature/open_feature_api.py b/open_feature/open_feature_api.py index 76448126..74b9034f 100644 --- a/open_feature/open_feature_api.py +++ b/open_feature/open_feature_api.py @@ -6,7 +6,7 @@ from open_feature.provider.provider import AbstractProvider _provider = None -_evaluation_context = None +_evaluation_context = EvaluationContext() def get_client(name: str = None, version: str = None) -> OpenFeatureClient: @@ -27,15 +27,3 @@ def set_provider(provider: AbstractProvider): def get_provider() -> typing.Optional[AbstractProvider]: global _provider return _provider - - -def get_evaluation_context() -> EvaluationContext: - global _evaluation_context - return _evaluation_context - - -def set_evaluation_context(evaluation_context: EvaluationContext): - global _evaluation_context - if evaluation_context is None: - raise GeneralError(error_message="No api level evaluation context") - _evaluation_context = evaluation_context diff --git a/open_feature/open_feature_client.py b/open_feature/open_feature_client.py index 1598a5e2..291d403e 100644 --- a/open_feature/open_feature_client.py +++ b/open_feature/open_feature_client.py @@ -14,6 +14,7 @@ before_hooks, error_hooks, ) +from open_feature.open_feature_evaluation_context import get_evaluation_context from open_feature.provider.provider import AbstractProvider @@ -193,10 +194,7 @@ def evaluate_flag_details( invocation_context.merge(ctx2=evaluation_context) merged_context = ( - # Todo pull the evaluation context below from api - EvaluationContext() - .merge(self.context) - .merge(invocation_context) + get_evaluation_context().merge(self.context).merge(invocation_context) ) flag_evaluation = self.create_provider_evaluation( diff --git a/open_feature/open_feature_evaluation_context.py b/open_feature/open_feature_evaluation_context.py new file mode 100644 index 00000000..1c78d7de --- /dev/null +++ b/open_feature/open_feature_evaluation_context.py @@ -0,0 +1,16 @@ +from open_feature.evaluation_context.evaluation_context import EvaluationContext +from open_feature.exception.exceptions import GeneralError + +_evaluation_context = EvaluationContext() + + +def get_evaluation_context() -> EvaluationContext: + global _evaluation_context + return _evaluation_context + + +def set_evaluation_context(evaluation_context: EvaluationContext): + global _evaluation_context + if evaluation_context is None: + raise GeneralError(error_message="No api level evaluation context") + _evaluation_context = evaluation_context diff --git a/tests/hooks/conftest.py b/tests/hooks/conftest.py index 995bbeb8..1fed4353 100644 --- a/tests/hooks/conftest.py +++ b/tests/hooks/conftest.py @@ -1,27 +1,16 @@ -import pytest - -from open_feature.flag_evaluation.flag_evaluation_details import FlagEvaluationDetails -from open_feature.flag_evaluation.flag_type import FlagType -from open_feature.hooks.hook import Hook - - -class TestHook(Hook): - def before(self, ctx, hints: dict): - pass +from unittest import mock - def after(self, ctx, details: FlagEvaluationDetails, hints: dict): - pass - - def error(self, ctx, exception: Exception, hints: dict): - return "Error" - - def finally_after(self, ctx, hints: dict): - pass +import pytest - def supports_flag_value_type(self, flag_type: FlagType) -> bool: - return True +from open_feature.evaluation_context.evaluation_context import EvaluationContext @pytest.fixture() -def test_hook(): - return TestHook() +def mock_hook(): + mock_hook = mock.MagicMock() + mock_hook.supports_flag_value_type.return_value = True + mock_hook.before.return_value = EvaluationContext() + mock_hook.after.return_value = None + mock_hook.error.return_value = None + mock_hook.finally_after.return_value = None + return mock_hook diff --git a/tests/hooks/test_hook_support.py b/tests/hooks/test_hook_support.py index defa51b6..fe906cd6 100644 --- a/tests/hooks/test_hook_support.py +++ b/tests/hooks/test_hook_support.py @@ -1,19 +1,54 @@ +from open_feature.flag_evaluation.flag_evaluation_details import FlagEvaluationDetails from open_feature.flag_evaluation.flag_type import FlagType -from open_feature.hooks.hook import Hook from open_feature.hooks.hook_context import HookContext -from open_feature.hooks.hook_support import error_hooks -from tests.hooks.conftest import TestHook +from open_feature.hooks.hook_support import ( + after_all_hooks, + after_hooks, + before_hooks, + error_hooks, +) -def setup(): - test_hook = TestHook() - assert isinstance(test_hook, Hook) +def test_error_hooks_run_error_method(mock_hook): + # Given + hook_context = HookContext("flag_key", FlagType.BOOLEAN, True, "") + # When + error_hooks(FlagType.BOOLEAN, hook_context, Exception, [mock_hook], {}) + # Then + mock_hook.supports_flag_value_type.assert_called_once() + mock_hook.error.assert_called_once() + + +def test_before_hooks_run_before_method(mock_hook): + # Given + hook_context = HookContext("flag_key", FlagType.BOOLEAN, True, "") + # When + before_hooks(FlagType.BOOLEAN, hook_context, [mock_hook], {}) + # Then + mock_hook.supports_flag_value_type.assert_called_once() + mock_hook.before.assert_called_once() + + +def test_after_hooks_run_after_method(mock_hook): + # Given + hook_context = HookContext("flag_key", FlagType.BOOLEAN, True, "") + flag_evaluation_details = FlagEvaluationDetails( + hook_context.flag_key, "val", "unknown" + ) + # When + after_hooks( + FlagType.BOOLEAN, hook_context, flag_evaluation_details, [mock_hook], {} + ) + # Then + mock_hook.supports_flag_value_type.assert_called_once() + mock_hook.after.assert_called_once() -def test_error_hooks_run_error_method(test_hook): +def test_finally_after_hooks_run_finally_after_method(mock_hook): # Given hook_context = HookContext("flag_key", FlagType.BOOLEAN, True, "") # When - error_hooks(FlagType.BOOLEAN, hook_context, Exception, [test_hook], {}) + after_all_hooks(FlagType.BOOLEAN, hook_context, [mock_hook], {}) # Then - assert True + mock_hook.supports_flag_value_type.assert_called_once() + mock_hook.finally_after.assert_called_once() From b9394f97625e7155da9557afb49fb87a766f992b Mon Sep 17 00:00:00 2001 From: Andrew Helsby Date: Mon, 22 Aug 2022 16:04:49 +0200 Subject: [PATCH 04/10] hooks: Change typing on iterables to be compatible with python 3.8 Signed-off-by: Andrew Helsby --- open_feature/hooks/hook_support.py | 12 ++++++++---- open_feature/open_feature_client.py | 4 ++-- 2 files changed, 10 insertions(+), 6 deletions(-) diff --git a/open_feature/hooks/hook_support.py b/open_feature/hooks/hook_support.py index 748eac17..d04f5534 100644 --- a/open_feature/hooks/hook_support.py +++ b/open_feature/hooks/hook_support.py @@ -1,4 +1,5 @@ import logging +import typing from functools import reduce from open_feature.evaluation_context.evaluation_context import EvaluationContext @@ -12,7 +13,7 @@ def error_hooks( flag_type: FlagType, hook_context: HookContext, exception: Exception, - hooks: list[Hook], + hooks: typing.List[Hook], hints: dict, ): kwargs = {"ctx": hook_context, "exception": exception, "hints": hints} @@ -32,7 +33,7 @@ def after_hooks( flag_type: FlagType, hook_context: HookContext, details: FlagEvaluationDetails, - hooks: list[Hook], + hooks: typing.List[Hook], hints: dict, ): kwargs = {"ctx": hook_context, "details": details, "hints": hints} @@ -42,7 +43,10 @@ def after_hooks( def before_hooks( - flag_type: FlagType, hook_context: HookContext, hooks: list[Hook], hints: dict + flag_type: FlagType, + hook_context: HookContext, + hooks: typing.List[Hook], + hints: dict, ) -> EvaluationContext: kwargs = {"ctx": hook_context, "hints": hints} executed_hooks = execute_hooks( @@ -57,7 +61,7 @@ def before_hooks( def execute_hooks( - flag_type: FlagType, hooks: list[Hook], hook_method: str, **kwargs + flag_type: FlagType, hooks: typing.List[Hook], hook_method: str, **kwargs ) -> list: if hooks: filtered_hooks = list( diff --git a/open_feature/open_feature_client.py b/open_feature/open_feature_client.py index 291d403e..1a6691eb 100644 --- a/open_feature/open_feature_client.py +++ b/open_feature/open_feature_client.py @@ -24,7 +24,7 @@ def __init__( name: str, version: str, context: EvaluationContext = EvaluationContext(), - hooks: list[Hook] = None, + hooks: typing.List[Hook] = None, provider: AbstractProvider = None, ): self.name = name @@ -33,7 +33,7 @@ def __init__( self.hooks = hooks or [] self.provider = provider - def add_hooks(self, hooks: list[Hook]): + def add_hooks(self, hooks: typing.List[Hook]): self.hooks = self.hooks + hooks def get_boolean_value( From f57169013a8dbd351983e02ae37701c3859eb1e3 Mon Sep 17 00:00:00 2001 From: Andrew Helsby Date: Mon, 22 Aug 2022 16:14:50 +0200 Subject: [PATCH 05/10] hooks: Add docstring for evaluate_flag_details method Signed-off-by: Andrew Helsby --- open_feature/open_feature_client.py | 21 +++++++++++++++------ 1 file changed, 15 insertions(+), 6 deletions(-) diff --git a/open_feature/open_feature_client.py b/open_feature/open_feature_client.py index 1a6691eb..a3514383 100644 --- a/open_feature/open_feature_client.py +++ b/open_feature/open_feature_client.py @@ -1,3 +1,4 @@ +import logging import typing from numbers import Number @@ -15,6 +16,7 @@ error_hooks, ) from open_feature.open_feature_evaluation_context import get_evaluation_context +from open_feature.provider.no_op_provider import NoOpProvider from open_feature.provider.provider import AbstractProvider @@ -165,13 +167,15 @@ def evaluate_flag_details( flag_evaluation_options: typing.Any = None, ) -> FlagEvaluationDetails: """ + Evaluate the flag requested by the user from the clients provider. - :param flag_type: - :param key: - :param default_value: - :param evaluation_context: - :param flag_evaluation_options: - :return: + :param flag_type: the type of the flag being returned + :param key: the string key of the selected flag + :param default_value: backup value returned if no result found by the provider + :param evaluation_context: Information for the purposes of flag evaluation + :param flag_evaluation_options: Additional flag evaluation information + :return: a FlagEvaluationDetails object with the fully evaluated flag from a + provider """ if evaluation_context is None: @@ -193,6 +197,7 @@ def evaluate_flag_details( ) invocation_context.merge(ctx2=evaluation_context) + # merge of: API.context, client.context, invocation.context merged_context = ( get_evaluation_context().merge(self.context).merge(invocation_context) ) @@ -246,6 +251,10 @@ def create_provider_evaluation( flag_evaluation_options, ) + if not self.provider: + logging.info("No provider configured, using no-op provider.") + NoOpProvider() + get_details_callable = { FlagType.BOOLEAN: self.provider.get_boolean_details, FlagType.NUMBER: self.provider.get_number_details, From e2d3de8b9c6ccebe5e489d3f4bc558df212af852 Mon Sep 17 00:00:00 2001 From: Andrew Helsby Date: Tue, 23 Aug 2022 17:57:51 +0200 Subject: [PATCH 06/10] hooks: Add docstring for evaluate_flag_details method Signed-off-by: Andrew Helsby --- open_feature/hooks/hook.py | 23 +++++---- open_feature/hooks/hook_context.py | 25 ++++------ open_feature/hooks/hook_support.py | 76 +++++++++++++++++++++-------- open_feature/hooks/hook_type.py | 8 +++ open_feature/open_feature_api.py | 2 - open_feature/open_feature_client.py | 4 +- 6 files changed, 89 insertions(+), 49 deletions(-) create mode 100644 open_feature/hooks/hook_type.py diff --git a/open_feature/hooks/hook.py b/open_feature/hooks/hook.py index c6d959e7..c2b9f67f 100644 --- a/open_feature/hooks/hook.py +++ b/open_feature/hooks/hook.py @@ -15,7 +15,7 @@ def before(self, hook_context: HookContext, hints: dict) -> EvaluationContext: :param hook_context: Information about the particular flag evaluation :param hints: An immutable mapping of data for users to communicate to the hooks. - :return: An optional EvaluationContext. If returned, it will + :return: An EvaluationContext. If returned, it will be merged with the EvaluationContext instances from other hooks, the client and API. """ @@ -31,21 +31,18 @@ def after( :param hook_context: Information about the particular flag evaluation :param details: Information about how the flag was resolved, including any resolved values. - :param hints: An immutable mapping of data for users to - communicate to the hooks. + :param hints: A mapping of data for users to communicate to the hooks. """ pass @abstractmethod def error(self, hook_context: HookContext, exception: Exception, hints: dict): """ - Run when evaluation encounters an error. This will always run. - Errors thrown will be swallowed. + Run when evaluation encounters an error. Errors thrown will be swallowed. :param hook_context: Information about the particular flag evaluation - :param exception: - :param hints: An immutable mapping of data for users to - communicate to the hooks. + :param exception: Ability to throw a specific exception if required + :param hints: A mapping of data for users to communicate to the hooks. """ pass @@ -56,11 +53,17 @@ def finally_after(self, hook_context: HookContext, hints: dict): This will always run. Errors will be swallowed. :param hook_context: Information about the particular flag evaluation - :param hints: An immutable mapping of data for users to - communicate to the hooks. + :param hints: A mapping of data for users to communicate to the hooks. """ pass @abstractmethod def supports_flag_value_type(self, flag_type: FlagType) -> bool: + """ + Check to see if the hook supports the particular flag type. + + :param flag_type: particular type of the flag + :return: a boolean containing whether the flag type is supported (True) + or not (False) + """ return True diff --git a/open_feature/hooks/hook_context.py b/open_feature/hooks/hook_context.py index 79eff1fc..13b90c40 100644 --- a/open_feature/hooks/hook_context.py +++ b/open_feature/hooks/hook_context.py @@ -1,20 +1,15 @@ +import typing +from dataclasses import dataclass + from open_feature.evaluation_context.evaluation_context import EvaluationContext from open_feature.flag_evaluation.flag_type import FlagType +@dataclass class HookContext: - def __init__( # noqa: CFQ002 - self, - flag_key: str, - flag_type: FlagType, - default_value, - evaluation_context: EvaluationContext, - client_metadata=None, - provider_metadata=None, - ): - self.flag_key = flag_key - self.flag_type = flag_type - self.default_value = default_value - self.evaluation_context = evaluation_context - self.client_metadata = client_metadata - self.provider_metadata = provider_metadata + flag_key: str + flag_type: FlagType + default_value: typing.Any + evaluation_context: EvaluationContext + client_metadata: dict = None + provider_metadata: dict = None diff --git a/open_feature/hooks/hook_support.py b/open_feature/hooks/hook_support.py index d04f5534..486f9fad 100644 --- a/open_feature/hooks/hook_support.py +++ b/open_feature/hooks/hook_support.py @@ -7,6 +7,7 @@ from open_feature.flag_evaluation.flag_type import FlagType from open_feature.hooks.hook import Hook from open_feature.hooks.hook_context import HookContext +from open_feature.hooks.hook_type import HookType def error_hooks( @@ -16,16 +17,38 @@ def error_hooks( hooks: typing.List[Hook], hints: dict, ): + """ + + :param flag_type: + :param hook_context: + :param exception: + :param hooks: + :param hints: + :return: + """ kwargs = {"ctx": hook_context, "exception": exception, "hints": hints} - execute_hooks(flag_type=flag_type, hooks=hooks, hook_method="error", **kwargs) + _execute_hooks( + flag_type=flag_type, hooks=hooks, hook_method=HookType.ERROR, **kwargs + ) def after_all_hooks( - flag_type: FlagType, hook_context: HookContext, hooks: list, hints: dict + flag_type: FlagType, + hook_context: HookContext, + hooks: typing.List[Hook], + hints: dict, ): + """ + + :param flag_type: + :param hook_context: + :param hooks: + :param hints: + :return: + """ kwargs = {"ctx": hook_context, "hints": hints} - execute_hooks( - flag_type=flag_type, hooks=hooks, hook_method="finally_after", **kwargs + _execute_hooks( + flag_type=flag_type, hooks=hooks, hook_method=HookType.FINALLY_AFTER, **kwargs ) @@ -36,9 +59,18 @@ def after_hooks( hooks: typing.List[Hook], hints: dict, ): + """ + + :param flag_type: + :param hook_context: + :param details: + :param hooks: + :param hints: + :return: + """ kwargs = {"ctx": hook_context, "details": details, "hints": hints} - execute_hooks_unchecked( - flag_type=flag_type, hooks=hooks, hook_method="after", **kwargs + _execute_hooks_unchecked( + flag_type=flag_type, hooks=hooks, hook_method=HookType.AFTER, **kwargs ) @@ -49,19 +81,19 @@ def before_hooks( hints: dict, ) -> EvaluationContext: kwargs = {"ctx": hook_context, "hints": hints} - executed_hooks = execute_hooks( - flag_type=flag_type, hooks=hooks, hook_method="before", **kwargs + executed_hooks = _execute_hooks( + flag_type=flag_type, hooks=hooks, hook_method=HookType.BEFORE, **kwargs ) - filtered_hooks = list(filter(lambda hook: hook is None, executed_hooks)) + filtered_hooks = list(filter(lambda hook: hook is not None, executed_hooks)) if filtered_hooks: return reduce(lambda a, b: a.merge(b), filtered_hooks) - else: - return EvaluationContext() + + return EvaluationContext() -def execute_hooks( - flag_type: FlagType, hooks: typing.List[Hook], hook_method: str, **kwargs +def _execute_hooks( + flag_type: FlagType, hooks: typing.List[Hook], hook_method: HookType, **kwargs ) -> list: if hooks: filtered_hooks = list( @@ -69,12 +101,14 @@ def execute_hooks( lambda hook: hook.supports_flag_value_type(flag_type=flag_type), hooks ) ) - return [execute_checked(hook, hook_method, **kwargs) for hook in filtered_hooks] + return [ + _execute_checked(hook, hook_method, **kwargs) for hook in filtered_hooks + ] return [] -def execute_hooks_unchecked( - flag_type: FlagType, hooks, hook_method: str, **kwargs +def _execute_hooks_unchecked( + flag_type: FlagType, hooks, hook_method: HookType, **kwargs ) -> list: if hooks: filtered_hooks = list( @@ -82,11 +116,13 @@ def execute_hooks_unchecked( lambda hook: hook.supports_flag_value_type(flag_type=flag_type), hooks ) ) - return [getattr(hook, hook_method)(**kwargs) for hook in filtered_hooks] + return [getattr(hook, hook_method.value)(**kwargs) for hook in filtered_hooks] + + return [] -def execute_checked(hook: Hook, hook_method: str, **kwargs): +def _execute_checked(hook: Hook, hook_method: HookType, **kwargs): try: - getattr(hook, hook_method)(**kwargs) + getattr(hook, hook_method.value)(**kwargs) except Exception: - logging.error(f"Exception when running {hook_method} hooks") + logging.error(f"Exception when running {hook_method.value} hooks") diff --git a/open_feature/hooks/hook_type.py b/open_feature/hooks/hook_type.py new file mode 100644 index 00000000..f00b558a --- /dev/null +++ b/open_feature/hooks/hook_type.py @@ -0,0 +1,8 @@ +from enum import Enum + + +class HookType(Enum): + BEFORE = "before" + AFTER = "after" + FINALLY_AFTER = "finally_after" + ERROR = "error" diff --git a/open_feature/open_feature_api.py b/open_feature/open_feature_api.py index 74b9034f..60c3f3d2 100644 --- a/open_feature/open_feature_api.py +++ b/open_feature/open_feature_api.py @@ -1,12 +1,10 @@ import typing -from open_feature.evaluation_context.evaluation_context import EvaluationContext from open_feature.exception.exceptions import GeneralError from open_feature.open_feature_client import OpenFeatureClient from open_feature.provider.provider import AbstractProvider _provider = None -_evaluation_context = EvaluationContext() def get_client(name: str = None, version: str = None) -> OpenFeatureClient: diff --git a/open_feature/open_feature_client.py b/open_feature/open_feature_client.py index a3514383..e9149030 100644 --- a/open_feature/open_feature_client.py +++ b/open_feature/open_feature_client.py @@ -25,13 +25,13 @@ def __init__( self, name: str, version: str, - context: EvaluationContext = EvaluationContext(), + context: EvaluationContext = None, hooks: typing.List[Hook] = None, provider: AbstractProvider = None, ): self.name = name self.version = version - self.context = context + self.context = context or EvaluationContext() self.hooks = hooks or [] self.provider = provider From 5e6738e4a6fddf182688909b15d0104701e1682e Mon Sep 17 00:00:00 2001 From: Andrew Helsby Date: Thu, 25 Aug 2022 15:53:08 +0200 Subject: [PATCH 07/10] hooks: docstring change requested in review Signed-off-by: Andrew Helsby --- open_feature/hooks/hook.py | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) diff --git a/open_feature/hooks/hook.py b/open_feature/hooks/hook.py index c2b9f67f..cff953c0 100644 --- a/open_feature/hooks/hook.py +++ b/open_feature/hooks/hook.py @@ -15,9 +15,8 @@ def before(self, hook_context: HookContext, hints: dict) -> EvaluationContext: :param hook_context: Information about the particular flag evaluation :param hints: An immutable mapping of data for users to communicate to the hooks. - :return: An EvaluationContext. If returned, it will - be merged with the EvaluationContext instances from other - hooks, the client and API. + :return: An EvaluationContext. It will be merged with the + EvaluationContext instances from other hooks, the client and API. """ pass From 6f2f536c7af22375d3190d822e8755c41a3c4551 Mon Sep 17 00:00:00 2001 From: Andrew Helsby Date: Tue, 30 Aug 2022 15:04:10 +0400 Subject: [PATCH 08/10] hooks: add docstrings and comments to Signed-off-by: Andrew Helsby --- .../evaluation_context/evaluation_context.py | 3 + open_feature/hooks/hook.py | 2 +- open_feature/hooks/hook_support.py | 67 ++++++++++--------- open_feature/open_feature_client.py | 16 +++-- .../open_feature_evaluation_context.py | 4 +- open_feature/provider/no_op_provider.py | 2 +- 6 files changed, 54 insertions(+), 40 deletions(-) diff --git a/open_feature/evaluation_context/evaluation_context.py b/open_feature/evaluation_context/evaluation_context.py index c14735b1..bba93548 100644 --- a/open_feature/evaluation_context/evaluation_context.py +++ b/open_feature/evaluation_context/evaluation_context.py @@ -4,6 +4,9 @@ def __init__(self, targeting_key: str = None, attributes: dict = None): self.attributes = attributes or {} def merge(self, ctx2: "EvaluationContext") -> "EvaluationContext": + if not (self and ctx2): + return self or ctx2 + self.attributes = {**self.attributes, **ctx2.attributes} self.targeting_key = ctx2.targeting_key or self.targeting_key diff --git a/open_feature/hooks/hook.py b/open_feature/hooks/hook.py index cff953c0..f6f44d36 100644 --- a/open_feature/hooks/hook.py +++ b/open_feature/hooks/hook.py @@ -40,7 +40,7 @@ def error(self, hook_context: HookContext, exception: Exception, hints: dict): Run when evaluation encounters an error. Errors thrown will be swallowed. :param hook_context: Information about the particular flag evaluation - :param exception: Ability to throw a specific exception if required + :param exception: The exception that was thrown :param hints: A mapping of data for users to communicate to the hooks. """ pass diff --git a/open_feature/hooks/hook_support.py b/open_feature/hooks/hook_support.py index 486f9fad..119359d0 100644 --- a/open_feature/hooks/hook_support.py +++ b/open_feature/hooks/hook_support.py @@ -17,15 +17,6 @@ def error_hooks( hooks: typing.List[Hook], hints: dict, ): - """ - - :param flag_type: - :param hook_context: - :param exception: - :param hooks: - :param hints: - :return: - """ kwargs = {"ctx": hook_context, "exception": exception, "hints": hints} _execute_hooks( flag_type=flag_type, hooks=hooks, hook_method=HookType.ERROR, **kwargs @@ -38,14 +29,6 @@ def after_all_hooks( hooks: typing.List[Hook], hints: dict, ): - """ - - :param flag_type: - :param hook_context: - :param hooks: - :param hints: - :return: - """ kwargs = {"ctx": hook_context, "hints": hints} _execute_hooks( flag_type=flag_type, hooks=hooks, hook_method=HookType.FINALLY_AFTER, **kwargs @@ -59,15 +42,6 @@ def after_hooks( hooks: typing.List[Hook], hints: dict, ): - """ - - :param flag_type: - :param hook_context: - :param details: - :param hooks: - :param hints: - :return: - """ kwargs = {"ctx": hook_context, "details": details, "hints": hints} _execute_hooks_unchecked( flag_type=flag_type, hooks=hooks, hook_method=HookType.AFTER, **kwargs @@ -81,7 +55,7 @@ def before_hooks( hints: dict, ) -> EvaluationContext: kwargs = {"ctx": hook_context, "hints": hints} - executed_hooks = _execute_hooks( + executed_hooks = _execute_hooks_unchecked( flag_type=flag_type, hooks=hooks, hook_method=HookType.BEFORE, **kwargs ) filtered_hooks = list(filter(lambda hook: hook is not None, executed_hooks)) @@ -95,6 +69,16 @@ def before_hooks( def _execute_hooks( flag_type: FlagType, hooks: typing.List[Hook], hook_method: HookType, **kwargs ) -> list: + """ + Run multiple hooks of any hook type. All of these hooks will be run through an + exception check. + + :param flag_type: particular type of flag + :param hooks: a list of hooks + :param hook_method: the type of hook that is being run + :param kwargs: arguments that need to be provided to the hook method + :return: a list of results from the applied hook methods + """ if hooks: filtered_hooks = list( filter( @@ -102,7 +86,8 @@ def _execute_hooks( ) ) return [ - _execute_checked(hook, hook_method, **kwargs) for hook in filtered_hooks + _execute_hook_checked(hook, hook_method, **kwargs) + for hook in filtered_hooks ] return [] @@ -110,6 +95,17 @@ def _execute_hooks( def _execute_hooks_unchecked( flag_type: FlagType, hooks, hook_method: HookType, **kwargs ) -> list: + """ + Execute a single hook without checking whether an exception is thrown. This is + used in the before and after hooks since any exception will be caught in the + client. + + :param flag_type: particular type of flag + :param hooks: a list of hooks + :param hook_method: the type of hook that is being run + :param kwargs: arguments that need to be provided to the hook method + :return: a list of results from the applied hook methods + """ if hooks: filtered_hooks = list( filter( @@ -121,8 +117,17 @@ def _execute_hooks_unchecked( return [] -def _execute_checked(hook: Hook, hook_method: HookType, **kwargs): +def _execute_hook_checked(hook: Hook, hook_method: HookType, **kwargs): + """ + Try and run a single hook and catch any exception thrown. This is used in the + after all and error hooks since any error thrown at this point needs to be caught. + + :param hook: a list of hooks + :param hook_method: the type of hook that is being run + :param kwargs: arguments that need to be provided to the hook method + :return: the result of the hook method + """ try: - getattr(hook, hook_method.value)(**kwargs) - except Exception: + return getattr(hook, hook_method.value)(**kwargs) + except Exception: # noqa logging.error(f"Exception when running {hook_method.value} hooks") diff --git a/open_feature/open_feature_client.py b/open_feature/open_feature_client.py index e9149030..db70ac43 100644 --- a/open_feature/open_feature_client.py +++ b/open_feature/open_feature_client.py @@ -3,7 +3,7 @@ from numbers import Number from open_feature.evaluation_context.evaluation_context import EvaluationContext -from open_feature.exception.exceptions import GeneralError, OpenFeatureError +from open_feature.exception.exceptions import GeneralError from open_feature.flag_evaluation.flag_evaluation_details import FlagEvaluationDetails from open_feature.flag_evaluation.flag_type import FlagType from open_feature.flag_evaluation.reason import Reason @@ -15,7 +15,7 @@ before_hooks, error_hooks, ) -from open_feature.open_feature_evaluation_context import get_evaluation_context +from open_feature.open_feature_evaluation_context import api_evaluation_context from open_feature.provider.no_op_provider import NoOpProvider from open_feature.provider.provider import AbstractProvider @@ -192,6 +192,9 @@ def evaluate_flag_details( merged_hooks = [] try: + # https://github.com/open-feature/spec/blob/main/specification/sections/03-evaluation-context.md + # Any resulting evaluation context from a before hook will overwrite + # duplicate fields defined globally, on the client, or in the invocation. invocation_context = before_hooks( flag_type, hook_context, merged_hooks, None ) @@ -199,7 +202,7 @@ def evaluate_flag_details( # merge of: API.context, client.context, invocation.context merged_context = ( - get_evaluation_context().merge(self.context).merge(invocation_context) + api_evaluation_context().merge(self.context).merge(invocation_context) ) flag_evaluation = self.create_provider_evaluation( @@ -213,13 +216,16 @@ def evaluate_flag_details( after_hooks(type, hook_context, flag_evaluation, merged_hooks, None) return flag_evaluation - except OpenFeatureError as ofe: + + # Catch any type of exception here since the user can provide any exception + # in the error hooks + except Exception as e: # noqa error_hooks(flag_type, hook_context, merged_hooks, None) return FlagEvaluationDetails( key=key, value=default_value, reason=Reason.ERROR, - error_code=ofe.error_message, + error_code=e.error_message, ) finally: diff --git a/open_feature/open_feature_evaluation_context.py b/open_feature/open_feature_evaluation_context.py index 1c78d7de..2d5e15dd 100644 --- a/open_feature/open_feature_evaluation_context.py +++ b/open_feature/open_feature_evaluation_context.py @@ -4,12 +4,12 @@ _evaluation_context = EvaluationContext() -def get_evaluation_context() -> EvaluationContext: +def api_evaluation_context() -> EvaluationContext: global _evaluation_context return _evaluation_context -def set_evaluation_context(evaluation_context: EvaluationContext): +def set_api_evaluation_context(evaluation_context: EvaluationContext): global _evaluation_context if evaluation_context is None: raise GeneralError(error_message="No api level evaluation context") diff --git a/open_feature/provider/no_op_provider.py b/open_feature/provider/no_op_provider.py index 93518b6d..53ff4e3d 100644 --- a/open_feature/provider/no_op_provider.py +++ b/open_feature/provider/no_op_provider.py @@ -17,7 +17,7 @@ def get_boolean_details( self, key: str, default_value: bool, - evaluation_context: EvaluationContext = EvaluationContext(), + evaluation_context: EvaluationContext = None, flag_evaluation_options: typing.Any = None, ): return FlagEvaluationDetails( From 904dfeaa05fc80029241080c1a8c64500477aef2 Mon Sep 17 00:00:00 2001 From: Andrew Helsby Date: Wed, 31 Aug 2022 20:01:10 +0400 Subject: [PATCH 09/10] hooks: Use correct exception in error hooks in the client Signed-off-by: Andrew Helsby --- open_feature/open_feature_client.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/open_feature/open_feature_client.py b/open_feature/open_feature_client.py index db70ac43..25c41aa0 100644 --- a/open_feature/open_feature_client.py +++ b/open_feature/open_feature_client.py @@ -220,7 +220,7 @@ def evaluate_flag_details( # Catch any type of exception here since the user can provide any exception # in the error hooks except Exception as e: # noqa - error_hooks(flag_type, hook_context, merged_hooks, None) + error_hooks(flag_type, hook_context, e, merged_hooks, None) return FlagEvaluationDetails( key=key, value=default_value, From 1c14744c202549e5b7216b962eb12ae16e6079e9 Mon Sep 17 00:00:00 2001 From: Andrew Helsby Date: Fri, 2 Sep 2022 10:18:53 +0400 Subject: [PATCH 10/10] hooks: Set empty evaluation context in no op provider to None Signed-off-by: Andrew Helsby --- open_feature/open_feature_client.py | 2 +- open_feature/provider/no_op_provider.py | 6 +++--- 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/open_feature/open_feature_client.py b/open_feature/open_feature_client.py index 25c41aa0..a3e33b66 100644 --- a/open_feature/open_feature_client.py +++ b/open_feature/open_feature_client.py @@ -259,7 +259,7 @@ def create_provider_evaluation( if not self.provider: logging.info("No provider configured, using no-op provider.") - NoOpProvider() + self.provider = NoOpProvider() get_details_callable = { FlagType.BOOLEAN: self.provider.get_boolean_details, diff --git a/open_feature/provider/no_op_provider.py b/open_feature/provider/no_op_provider.py index 53ff4e3d..b09d53be 100644 --- a/open_feature/provider/no_op_provider.py +++ b/open_feature/provider/no_op_provider.py @@ -31,7 +31,7 @@ def get_string_details( self, key: str, default_value: str, - evaluation_context: EvaluationContext = EvaluationContext(), + evaluation_context: EvaluationContext = None, flag_evaluation_options: typing.Any = None, ): return FlagEvaluationDetails( @@ -45,7 +45,7 @@ def get_number_details( self, key: str, default_value: Number, - evaluation_context: EvaluationContext = EvaluationContext(), + evaluation_context: EvaluationContext = None, flag_evaluation_options: typing.Any = None, ): return FlagEvaluationDetails( @@ -59,7 +59,7 @@ def get_object_details( self, key: str, default_value: dict, - evaluation_context: EvaluationContext = EvaluationContext(), + evaluation_context: EvaluationContext = None, flag_evaluation_options: typing.Any = None, ): return FlagEvaluationDetails(