openfeature-provider-flagd 0.1.5__py3-none-any.whl → 0.2.1__py3-none-any.whl

openfeature/contrib/provider/flagd/resolvers/grpc.py

@@ -1,36 +1,230 @@
+import logging
+import threading
+import time
 import typing
 
 import grpc
+from cachebox import BaseCacheImpl, LRUCache
+from google.protobuf.json_format import MessageToDict
 from google.protobuf.struct_pb2 import Struct
+from grpc import ChannelConnectivity
 
 from openfeature.evaluation_context import EvaluationContext
+from openfeature.event import ProviderEventDetails
 from openfeature.exception import (
+    ErrorCode,
     FlagNotFoundError,
     GeneralError,
     InvalidContextError,
     ParseError,
+    ProviderNotReadyError,
     TypeMismatchError,
 )
-from openfeature.flag_evaluation import FlagResolutionDetails
+from openfeature.flag_evaluation import FlagResolutionDetails, Reason
+from openfeature.schemas.protobuf.flagd.evaluation.v1 import (
+    evaluation_pb2,
+    evaluation_pb2_grpc,
+)
 
-from ..config import Config
+from ..config import CacheType, Config
 from ..flag_type import FlagType
-from ..proto.schema.v1 import schema_pb2, schema_pb2_grpc
+
+if typing.TYPE_CHECKING:
+    from google.protobuf.message import Message
 
 T = typing.TypeVar("T")
 
+logger = logging.getLogger("openfeature.contrib")
+
 
 class GrpcResolver:
-    def __init__(self, config: Config):
+    def __init__(
+        self,
+        config: Config,
+        emit_provider_ready: typing.Callable[[ProviderEventDetails], None],
+        emit_provider_error: typing.Callable[[ProviderEventDetails], None],
+        emit_provider_stale: typing.Callable[[ProviderEventDetails], None],
+        emit_provider_configuration_changed: typing.Callable[
+            [ProviderEventDetails], None
+        ],
+    ):
+        self.active = False
         self.config = config
-        channel_factory = (
-            grpc.secure_channel if self.config.tls else grpc.insecure_channel
+        self.emit_provider_ready = emit_provider_ready
+        self.emit_provider_error = emit_provider_error
+        self.emit_provider_stale = emit_provider_stale
+        self.emit_provider_configuration_changed = emit_provider_configuration_changed
+        self.cache: typing.Optional[BaseCacheImpl] = (
+            LRUCache(maxsize=self.config.max_cache_size)
+            if self.config.cache == CacheType.LRU
+            else None
         )
-        self.channel = channel_factory(f"{self.config.host}:{self.config.port}")
-        self.stub = schema_pb2_grpc.ServiceStub(self.channel)
+
+        self.retry_grace_period = config.retry_grace_period
+        self.streamline_deadline_seconds = config.stream_deadline_ms * 0.001
+        self.deadline = config.deadline_ms * 0.001
+        self.connected = False
+        self.channel = self._generate_channel(config)
+        self.stub = evaluation_pb2_grpc.ServiceStub(self.channel)
+
+        self.thread: typing.Optional[threading.Thread] = None
+        self.timer: typing.Optional[threading.Timer] = None
+
+        self.start_time = time.time()
+
+    def _generate_channel(self, config: Config) -> grpc.Channel:
+        target = f"{config.host}:{config.port}"
+        # Create the channel with the service config
+        options = [
+            ("grpc.keepalive_time_ms", config.keep_alive_time),
+            ("grpc.initial_reconnect_backoff_ms", config.retry_backoff_ms),
+            ("grpc.max_reconnect_backoff_ms", config.retry_backoff_max_ms),
+            ("grpc.min_reconnect_backoff_ms", config.deadline_ms),
+        ]
+        if config.tls:
+            channel_args = {
+                "options": options,
+                "credentials": grpc.ssl_channel_credentials(),
+            }
+            if config.cert_path:
+                with open(config.cert_path, "rb") as f:
+                    channel_args["credentials"] = grpc.ssl_channel_credentials(f.read())
+
+            channel = grpc.secure_channel(target, **channel_args)
+
+        else:
+            channel = grpc.insecure_channel(
+                target,
+                options=options,
+            )
+
+        return channel
+
+    def initialize(self, evaluation_context: EvaluationContext) -> None:
+        self.connect()
 
     def shutdown(self) -> None:
+        self.active = False
+        self.channel.unsubscribe(self._state_change_callback)
         self.channel.close()
+        if self.timer and self.timer.is_alive():
+            logger.debug("gRPC error timer cancelled due to shutdown")
+            self.timer.cancel()
+        if self.cache:
+            self.cache.clear()
+
+    def connect(self) -> None:
+        self.active = True
+
+        # Run monitoring in a separate thread
+        self.monitor_thread = threading.Thread(
+            target=self.monitor, daemon=True, name="FlagdGrpcServiceMonitorThread"
+        )
+        self.monitor_thread.start()
+        ## block until ready or deadline reached
+        timeout = self.deadline + time.time()
+        while not self.connected and time.time() < timeout:
+            time.sleep(0.05)
+        logger.debug("Finished blocking gRPC state initialization")
+
+        if not self.connected:
+            raise ProviderNotReadyError(
+                "Blocking init finished before data synced. Consider increasing startup deadline to avoid inconsistent evaluations."
+            )
+
+    def monitor(self) -> None:
+        self.channel.subscribe(self._state_change_callback, try_to_connect=True)
+
+    def _state_change_callback(self, new_state: ChannelConnectivity) -> None:
+        logger.debug(f"gRPC state change: {new_state}")
+        if (
+            new_state == grpc.ChannelConnectivity.READY
+            or new_state == grpc.ChannelConnectivity.IDLE
+        ):
+            if not self.thread or not self.thread.is_alive():
+                self.thread = threading.Thread(
+                    target=self.listen,
+                    daemon=True,
+                    name="FlagdGrpcServiceWorkerThread",
+                )
+                self.thread.start()
+
+            if self.timer and self.timer.is_alive():
+                logger.debug("gRPC error timer expired")
+                self.timer.cancel()
+
+        elif new_state == ChannelConnectivity.TRANSIENT_FAILURE:
+            # this is the failed reconnect attempt so we are going into stale
+            self.emit_provider_stale(
+                ProviderEventDetails(
+                    message="gRPC sync disconnected, reconnecting",
+                )
+            )
+            self.start_time = time.time()
+            # adding a timer, so we can emit the error event after time
+            self.timer = threading.Timer(self.retry_grace_period, self.emit_error)
+
+            logger.debug("gRPC error timer started")
+            self.timer.start()
+            self.connected = False
+
+    def emit_error(self) -> None:
+        logger.debug("gRPC error emitted")
+        if self.cache:
+            self.cache.clear()
+        self.emit_provider_error(
+            ProviderEventDetails(
+                message="gRPC sync disconnected, reconnecting",
+                error_code=ErrorCode.GENERAL,
+            )
+        )
+
+    def listen(self) -> None:
+        logger.debug("gRPC starting listener thread")
+        call_args = (
+            {"timeout": self.streamline_deadline_seconds}
+            if self.streamline_deadline_seconds > 0
+            else {}
+        )
+        request = evaluation_pb2.EventStreamRequest()
+
+        # defining a never ending loop to recreate the stream
+        while self.active:
+            try:
+                logger.debug("Setting up gRPC sync flags connection")
+                for message in self.stub.EventStream(
+                    request, wait_for_ready=True, **call_args
+                ):
+                    if message.type == "provider_ready":
+                        self.emit_provider_ready(
+                            ProviderEventDetails(
+                                message="gRPC sync connection established"
+                            )
+                        )
+                        self.connected = True
+                    elif message.type == "configuration_change":
+                        data = MessageToDict(message)["data"]
+                        self.handle_changed_flags(data)
+
+                    if not self.active:
+                        logger.info("Terminating gRPC sync thread")
+                        return
+            except grpc.RpcError as e:  # noqa: PERF203
+                # although it seems like this error log is not interesting, without it, the retry is not working as expected
+                logger.debug(f"SyncFlags stream error, {e.code()=} {e.details()=}")
+            except ParseError:
+                logger.exception(
+                    f"Could not parse flag data using flagd syntax: {message=}"
+                )
+
+    def handle_changed_flags(self, data: typing.Any) -> None:
+        changed_flags = list(data["flags"].keys())
+
+        if self.cache:
+            for flag in changed_flags:
+                self.cache.pop(flag)
+
+        self.emit_provider_configuration_changed(ProviderEventDetails(changed_flags))
 
     def resolve_boolean_details(
         self,
@@ -72,41 +266,54 @@ class GrpcResolver:
     ) -> FlagResolutionDetails[typing.Union[dict, list]]:
         return self._resolve(key, FlagType.OBJECT, default_value, evaluation_context)
 
-    def _resolve(
+    def _resolve(  # noqa: PLR0915 C901
         self,
         flag_key: str,
         flag_type: FlagType,
         default_value: T,
         evaluation_context: typing.Optional[EvaluationContext],
     ) -> FlagResolutionDetails[T]:
+        if self.cache is not None and flag_key in self.cache:
+            cached_flag: FlagResolutionDetails[T] = self.cache[flag_key]
+            cached_flag.reason = Reason.CACHED
+            return cached_flag
+
         context = self._convert_context(evaluation_context)
-        call_args = {"timeout": self.config.timeout}
+        call_args = {"timeout": self.deadline, "wait_for_ready": True}
         try:
+            request: Message
             if flag_type == FlagType.BOOLEAN:
-                request = schema_pb2.ResolveBooleanRequest(  # type:ignore[attr-defined]
+                request = evaluation_pb2.ResolveBooleanRequest(
                     flag_key=flag_key, context=context
                 )
                 response = self.stub.ResolveBoolean(request, **call_args)
+                value = response.value
             elif flag_type == FlagType.STRING:
-                request = schema_pb2.ResolveStringRequest(  # type:ignore[attr-defined]
+                request = evaluation_pb2.ResolveStringRequest(
                     flag_key=flag_key, context=context
                 )
                 response = self.stub.ResolveString(request, **call_args)
+                value = response.value
             elif flag_type == FlagType.OBJECT:
-                request = schema_pb2.ResolveObjectRequest(  # type:ignore[attr-defined]
+                request = evaluation_pb2.ResolveObjectRequest(
                     flag_key=flag_key, context=context
                 )
                 response = self.stub.ResolveObject(request, **call_args)
+                value = MessageToDict(response, preserving_proto_field_name=True)[
+                    "value"
+                ]
             elif flag_type == FlagType.FLOAT:
-                request = schema_pb2.ResolveFloatRequest(  # type:ignore[attr-defined]
+                request = evaluation_pb2.ResolveFloatRequest(
                     flag_key=flag_key, context=context
                 )
                 response = self.stub.ResolveFloat(request, **call_args)
+                value = response.value
             elif flag_type == FlagType.INTEGER:
-                request = schema_pb2.ResolveIntRequest(  # type:ignore[attr-defined]
+                request = evaluation_pb2.ResolveIntRequest(
                     flag_key=flag_key, context=context
                 )
                 response = self.stub.ResolveInt(request, **call_args)
+                value = response.value
             else:
                 raise ValueError(f"Unknown flag type: {flag_type}")
 
@@ -123,12 +330,17 @@ class GrpcResolver:
             raise GeneralError(message) from e
 
         # Got a valid flag and valid type. Return it.
-        return FlagResolutionDetails(
-            value=response.value,
+        result = FlagResolutionDetails(
+            value=value,
             reason=response.reason,
             variant=response.variant,
         )
 
+        if response.reason == Reason.STATIC and self.cache is not None:
+            self.cache.insert(flag_key, result)
+
+        return result
+
     def _convert_context(
         self, evaluation_context: typing.Optional[EvaluationContext]
     ) -> Struct:

openfeature/contrib/provider/flagd/resolvers/in_process.py

@@ -1,44 +1,54 @@
-import time
 import typing
 
-from json_logic import builtins, jsonLogic  # type: ignore[import-untyped]
-
+from openfeature.contrib.provider.flagd.resolvers.process.connector.file_watcher import (
+    FileWatcher,
+)
 from openfeature.evaluation_context import EvaluationContext
+from openfeature.event import ProviderEventDetails
 from openfeature.exception import FlagNotFoundError, ParseError
 from openfeature.flag_evaluation import FlagResolutionDetails, Reason
-from openfeature.provider.provider import AbstractProvider
 
 from ..config import Config
-from .process.custom_ops import ends_with, fractional, sem_ver, starts_with
-from .process.file_watcher import FileWatcherFlagStore
+from .process.connector import FlagStateConnector
+from .process.connector.grpc_watcher import GrpcWatcher
+from .process.flags import FlagStore
+from .process.targeting import targeting
 
 T = typing.TypeVar("T")
 
 
 class InProcessResolver:
-    OPERATORS: typing.ClassVar[dict] = {
-        **builtins.BUILTINS,
-        "fractional": fractional,
-        "starts_with": starts_with,
-        "ends_with": ends_with,
-        "sem_ver": sem_ver,
-    }
-
-    def __init__(self, config: Config, provider: AbstractProvider):
+    def __init__(
+        self,
+        config: Config,
+        emit_provider_ready: typing.Callable[[ProviderEventDetails, dict], None],
+        emit_provider_error: typing.Callable[[ProviderEventDetails], None],
+        emit_provider_stale: typing.Callable[[ProviderEventDetails], None],
+        emit_provider_configuration_changed: typing.Callable[
+            [ProviderEventDetails], None
+        ],
+    ):
         self.config = config
-        self.provider = provider
-        if not self.config.offline_flag_source_path:
-            raise ValueError(
-                "offline_flag_source_path must be provided when using in-process resolver"
+        self.flag_store = FlagStore(emit_provider_configuration_changed)
+        self.connector: FlagStateConnector = (
+            FileWatcher(
+                self.config, self.flag_store, emit_provider_ready, emit_provider_error
+            )
+            if self.config.offline_flag_source_path
+            else GrpcWatcher(
+                self.config,
+                self.flag_store,
+                emit_provider_ready,
+                emit_provider_error,
+                emit_provider_stale,
             )
-        self.flag_store = FileWatcherFlagStore(
-            self.config.offline_flag_source_path,
-            self.provider,
-            self.config.offline_poll_interval_seconds,
         )
 
+    def initialize(self, evaluation_context: EvaluationContext) -> None:
+        self.connector.initialize(evaluation_context)
+
     def shutdown(self) -> None:
-        self.flag_store.shutdown()
+        self.connector.shutdown()
 
     def resolve_boolean_details(
         self,
@@ -62,7 +72,10 @@ class InProcessResolver:
         default_value: float,
         evaluation_context: typing.Optional[EvaluationContext] = None,
     ) -> FlagResolutionDetails[float]:
-        return self._resolve(key, default_value, evaluation_context)
+        result = self._resolve(key, default_value, evaluation_context)
+        if isinstance(result.value, int):
+            result.value = float(result.value)
+        return result
 
     def resolve_integer_details(
         self,
@@ -97,12 +110,8 @@ class InProcessResolver:
             variant, value = flag.default
             return FlagResolutionDetails(value, variant=variant, reason=Reason.STATIC)
 
-        json_logic_context = evaluation_context.attributes if evaluation_context else {}
-        json_logic_context["$flagd"] = {"flagKey": key, "timestamp": int(time.time())}
-        json_logic_context["targetingKey"] = (
-            evaluation_context.targeting_key if evaluation_context else None
-        )
-        variant = jsonLogic(flag.targeting, json_logic_context, self.OPERATORS)
+        variant = targeting(flag.key, flag.targeting, evaluation_context)
+
         if variant is None:
             variant, value = flag.default
             return FlagResolutionDetails(value, variant=variant, reason=Reason.DEFAULT)

openfeature/contrib/provider/flagd/resolvers/process/connector/__init__.py

@@ -0,0 +1,11 @@
+import typing
+
+from openfeature.evaluation_context import EvaluationContext
+
+
+class FlagStateConnector(typing.Protocol):
+    def initialize(
+        self, evaluation_context: EvaluationContext
+    ) -> None: ...  # pragma: no cover
+
+    def shutdown(self) -> None: ...  # pragma: no cover

openfeature/contrib/provider/flagd/resolvers/process/connector/file_watcher.py

@@ -0,0 +1,107 @@
+import json
+import logging
+import os
+import threading
+import time
+import typing
+
+import yaml
+
+from openfeature.contrib.provider.flagd.config import Config
+from openfeature.contrib.provider.flagd.resolvers.process.connector import (
+    FlagStateConnector,
+)
+from openfeature.contrib.provider.flagd.resolvers.process.flags import FlagStore
+from openfeature.evaluation_context import EvaluationContext
+from openfeature.event import ProviderEventDetails
+from openfeature.exception import ParseError, ProviderNotReadyError
+
+logger = logging.getLogger("openfeature.contrib")
+
+
+class FileWatcher(FlagStateConnector):
+    def __init__(
+        self,
+        config: Config,
+        flag_store: FlagStore,
+        emit_provider_ready: typing.Callable[[ProviderEventDetails, dict], None],
+        emit_provider_error: typing.Callable[[ProviderEventDetails], None],
+    ):
+        if config.offline_flag_source_path is None:
+            raise ValueError(
+                f"`config.offline_flag_source_path` parameter invalid: {config.offline_flag_source_path}"
+            )
+        else:
+            self.file_path = config.offline_flag_source_path
+
+        self.emit_provider_ready = emit_provider_ready
+        self.emit_provider_error = emit_provider_error
+        self.deadline_seconds = config.deadline_ms * 0.001
+
+        self.last_modified = 0.0
+        self.flag_store = flag_store
+        self.should_emit_ready_on_success = False
+
+    def initialize(self, evaluation_context: EvaluationContext) -> None:
+        self.active = True
+        self.thread = threading.Thread(
+            target=self.refresh_file, daemon=True, name="FlagdFileWatcherWorkerThread"
+        )
+        self.thread.start()
+
+        # Let this throw exceptions so that provider status is set correctly
+        try:
+            self.should_emit_ready_on_success = True
+            self._load_data()
+        except Exception as err:
+            raise ProviderNotReadyError from err
+
+    def shutdown(self) -> None:
+        self.active = False
+
+    def refresh_file(self) -> None:
+        while self.active:
+            time.sleep(self.deadline_seconds)
+            logger.debug("checking for new flag store contents from file")
+            self.safe_load_data()
+
+    def safe_load_data(self) -> None:
+        try:
+            last_modified = os.path.getmtime(self.file_path)
+            if last_modified > self.last_modified:
+                self._load_data(last_modified)
+        except FileNotFoundError:
+            self.handle_error("Provided file path not valid")
+        except json.JSONDecodeError:
+            self.handle_error("Could not parse JSON flag data from file")
+        except yaml.error.YAMLError:
+            self.handle_error("Could not parse YAML flag data from file")
+        except ParseError:
+            self.handle_error("Could not parse flag data using flagd syntax")
+        except Exception:
+            self.handle_error("Could not read flags from file")
+
+    def _load_data(self, modified_time: typing.Optional[float] = None) -> None:
+        with open(self.file_path) as file:
+            if self.file_path.endswith(".yaml"):
+                data = yaml.safe_load(file)
+            else:
+                data = json.load(file)
+
+            self.flag_store.update(data)
+
+            if self.should_emit_ready_on_success:
+                self.emit_provider_ready(
+                    ProviderEventDetails(
+                        message="Reloading file contents recovered from error state"
+                    ),
+                    {},
+                )
+                self.should_emit_ready_on_success = False
+
+        self.last_modified = modified_time or os.path.getmtime(self.file_path)
+
+    def handle_error(self, error_message: str) -> None:
+        logger.exception(error_message)
+        self.should_emit_ready_on_success = True
+        self.emit_provider_error(ProviderEventDetails(message=error_message))