feat: update provider status when provider emits events

Signed-off-by: Federico Bond <[email protected]>

Author: federicobond

openfeature/provider/_registry.py

@@ -74,34 +74,78 @@ def _initialize_provider(self, provider: FeatureProvider) -> None:
         try:
             if hasattr(provider, "initialize"):
                 provider.initialize(self._get_evaluation_context())
-            self._set_provider_status(provider, ProviderStatus.READY)
+            self.dispatch_event(
+                provider, ProviderEvent.PROVIDER_READY, ProviderEventDetails()
+            )
         except Exception as err:
             if (
                 isinstance(err, OpenFeatureError)
                 and err.error_code == ErrorCode.PROVIDER_FATAL
             ):
-                self._set_provider_status(provider, ProviderStatus.FATAL)
+                self.dispatch_event(
+                    provider,
+                    ProviderEvent.PROVIDER_ERROR,
+                    ProviderEventDetails(
+                        message=f"Provider initialization failed: {err}",
+                        error_code=ErrorCode.PROVIDER_FATAL,
+                    ),
+                )
             else:
-                self._set_provider_status(provider, ProviderStatus.ERROR)
+                self.dispatch_event(
+                    provider,
+                    ProviderEvent.PROVIDER_ERROR,
+                    ProviderEventDetails(
+                        message=f"Provider initialization failed: {err}",
+                        error_code=ErrorCode.GENERAL,
+                    ),
+                )
 
     def _shutdown_provider(self, provider: FeatureProvider) -> None:
         try:
             if hasattr(provider, "shutdown"):
                 provider.shutdown()
-            self._set_provider_status(provider, ProviderStatus.NOT_READY)
-        except Exception:
-            self._set_provider_status(provider, ProviderStatus.FATAL)
+            self.dispatch_event(
+                provider, ProviderEvent.PROVIDER_READY, ProviderEventDetails()
+            )
+        except Exception as err:
+            self.dispatch_event(
+                provider,
+                ProviderEvent.PROVIDER_ERROR,
+                ProviderEventDetails(
+                    message=f"Provider shutdown failed: {err}",
+                    error_code=ErrorCode.PROVIDER_FATAL,
+                ),
+            )
 
     def get_provider_status(self, provider: FeatureProvider) -> ProviderStatus:
         return self._provider_status.get(provider, ProviderStatus.NOT_READY)
 
-    def _set_provider_status(
-        self, provider: FeatureProvider, status: ProviderStatus
+    def dispatch_event(
+        self,
+        provider: FeatureProvider,
+        event: ProviderEvent,
+        details: ProviderEventDetails,
     ) -> None:
-        self._provider_status[provider] = status
-
-        if event := ProviderEvent.from_provider_status(status):
-            run_handlers_for_provider(provider, event, ProviderEventDetails())
+        self._update_provider_status(provider, event, details)
+        run_handlers_for_provider(provider, event, details)
+
+    def _update_provider_status(
+        self,
+        provider: FeatureProvider,
+        event: ProviderEvent,
+        details: ProviderEventDetails,
+    ) -> None:
+        if event == ProviderEvent.PROVIDER_READY:
+            self._provider_status[provider] = ProviderStatus.READY
+        elif event == ProviderEvent.PROVIDER_STALE:
+            self._provider_status[provider] = ProviderStatus.STALE
+        elif event == ProviderEvent.PROVIDER_ERROR:
+            status = (
+                ProviderStatus.FATAL
+                if details.error_code == ErrorCode.PROVIDER_FATAL
+                else ProviderStatus.ERROR
+            )
+            self._provider_status[provider] = status
 
 
 default_registry = ProviderRegistry()

openfeature/provider/provider.py

@@ -1,7 +1,6 @@
 import typing
 from abc import abstractmethod
 
-from openfeature._event_support import run_handlers_for_provider
 from openfeature.evaluation_context import EvaluationContext
 from openfeature.event import ProviderEvent, ProviderEventDetails
 from openfeature.flag_evaluation import FlagResolutionDetails
@@ -84,4 +83,6 @@ def emit_provider_stale(self, details: ProviderEventDetails) -> None:
         self.emit(ProviderEvent.PROVIDER_STALE, details)
 
     def emit(self, event: ProviderEvent, details: ProviderEventDetails) -> None:
-        run_handlers_for_provider(self, event, details)
+        from openfeature.provider._registry import default_registry
+
+        default_registry.dispatch_event(self, event, details)

tests/test_api.py

@@ -20,7 +20,7 @@
 from openfeature.event import EventDetails, ProviderEvent, ProviderEventDetails
 from openfeature.exception import ErrorCode, GeneralError
 from openfeature.hook import Hook
-from openfeature.provider import FeatureProvider, Metadata
+from openfeature.provider import FeatureProvider, Metadata, ProviderStatus
 from openfeature.provider.no_op_provider import NoOpProvider
 
 
@@ -313,3 +313,32 @@ def test_provider_ready_handlers_run_if_provider_initialize_function_terminates_
 
     # Then
     spy.provider_ready.assert_called_once()
+
+
+def test_provider_status_is_updated_after_provider_emits_event():
+    # Given
+    provider = NoOpProvider()
+    set_provider(provider)
+    client = get_client()
+
+    # When
+    provider.emit_provider_error(ProviderEventDetails(error_code=ErrorCode.GENERAL))
+    # Then
+    assert client.get_provider_status() == ProviderStatus.ERROR
+
+    # When
+    provider.emit_provider_error(
+        ProviderEventDetails(error_code=ErrorCode.PROVIDER_FATAL)
+    )
+    # Then
+    assert client.get_provider_status() == ProviderStatus.FATAL
+
+    # When
+    provider.emit_provider_stale(ProviderEventDetails())
+    # Then
+    assert client.get_provider_status() == ProviderStatus.STALE
+
+    # When
+    provider.emit_provider_ready(ProviderEventDetails())
+    # Then
+    assert client.get_provider_status() == ProviderStatus.READY