openfeature-provider-flagd 0.1.4__py3-none-any.whl → 0.2.0__py3-none-any.whl

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

@@ -0,0 +1,354 @@
+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, Reason
+from openfeature.schemas.protobuf.flagd.evaluation.v1 import (
+    evaluation_pb2,
+    evaluation_pb2_grpc,
+)
+
+from ..config import CacheType, Config
+from ..flag_type import FlagType
+
+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,
+        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
+        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.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 == ChannelConnectivity.READY:
+            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,
+        key: str,
+        default_value: bool,
+        evaluation_context: typing.Optional[EvaluationContext] = None,
+    ) -> FlagResolutionDetails[bool]:
+        return self._resolve(key, FlagType.BOOLEAN, default_value, evaluation_context)
+
+    def resolve_string_details(
+        self,
+        key: str,
+        default_value: str,
+        evaluation_context: typing.Optional[EvaluationContext] = None,
+    ) -> FlagResolutionDetails[str]:
+        return self._resolve(key, FlagType.STRING, default_value, evaluation_context)
+
+    def resolve_float_details(
+        self,
+        key: str,
+        default_value: float,
+        evaluation_context: typing.Optional[EvaluationContext] = None,
+    ) -> FlagResolutionDetails[float]:
+        return self._resolve(key, FlagType.FLOAT, default_value, evaluation_context)
+
+    def resolve_integer_details(
+        self,
+        key: str,
+        default_value: int,
+        evaluation_context: typing.Optional[EvaluationContext] = None,
+    ) -> FlagResolutionDetails[int]:
+        return self._resolve(key, FlagType.INTEGER, default_value, evaluation_context)
+
+    def resolve_object_details(
+        self,
+        key: str,
+        default_value: typing.Union[dict, list],
+        evaluation_context: typing.Optional[EvaluationContext] = None,
+    ) -> FlagResolutionDetails[typing.Union[dict, list]]:
+        return self._resolve(key, FlagType.OBJECT, default_value, evaluation_context)
+
+    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.deadline}
+        try:
+            request: Message
+            if flag_type == FlagType.BOOLEAN:
+                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 = 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 = 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 = 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 = 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}")
+
+        except grpc.RpcError as e:
+            code = e.code()
+            message = f"received grpc status code {code}"
+
+            if code == grpc.StatusCode.NOT_FOUND:
+                raise FlagNotFoundError(message) from e
+            elif code == grpc.StatusCode.INVALID_ARGUMENT:
+                raise TypeMismatchError(message) from e
+            elif code == grpc.StatusCode.DATA_LOSS:
+                raise ParseError(message) from e
+            raise GeneralError(message) from e
+
+        # Got a valid flag and valid type. Return it.
+        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:
+        s = Struct()
+        if evaluation_context:
+            try:
+                s["targetingKey"] = evaluation_context.targeting_key
+                s.update(evaluation_context.attributes)
+            except ValueError as exc:
+                message = (
+                    "could not serialize evaluation context to google.protobuf.Struct"
+                )
+                raise InvalidContextError(message) from exc
+        return s

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

@@ -0,0 +1,131 @@
+import typing
+
+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 ..config import Config
+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:
+    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.config = config
+        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,
+            )
+        )
+
+    def initialize(self, evaluation_context: EvaluationContext) -> None:
+        self.connector.initialize(evaluation_context)
+
+    def shutdown(self) -> None:
+        self.connector.shutdown()
+
+    def resolve_boolean_details(
+        self,
+        key: str,
+        default_value: bool,
+        evaluation_context: typing.Optional[EvaluationContext] = None,
+    ) -> FlagResolutionDetails[bool]:
+        return self._resolve(key, default_value, evaluation_context)
+
+    def resolve_string_details(
+        self,
+        key: str,
+        default_value: str,
+        evaluation_context: typing.Optional[EvaluationContext] = None,
+    ) -> FlagResolutionDetails[str]:
+        return self._resolve(key, default_value, evaluation_context)
+
+    def resolve_float_details(
+        self,
+        key: str,
+        default_value: float,
+        evaluation_context: typing.Optional[EvaluationContext] = None,
+    ) -> FlagResolutionDetails[float]:
+        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,
+        key: str,
+        default_value: int,
+        evaluation_context: typing.Optional[EvaluationContext] = None,
+    ) -> FlagResolutionDetails[int]:
+        return self._resolve(key, default_value, evaluation_context)
+
+    def resolve_object_details(
+        self,
+        key: str,
+        default_value: typing.Union[dict, list],
+        evaluation_context: typing.Optional[EvaluationContext] = None,
+    ) -> FlagResolutionDetails[typing.Union[dict, list]]:
+        return self._resolve(key, default_value, evaluation_context)
+
+    def _resolve(
+        self,
+        key: str,
+        default_value: T,
+        evaluation_context: typing.Optional[EvaluationContext] = None,
+    ) -> FlagResolutionDetails[T]:
+        flag = self.flag_store.get_flag(key)
+        if not flag:
+            raise FlagNotFoundError(f"Flag with key {key} not present in flag store.")
+
+        if flag.state == "DISABLED":
+            return FlagResolutionDetails(default_value, reason=Reason.DISABLED)
+
+        if not flag.targeting:
+            variant, value = flag.default
+            return FlagResolutionDetails(value, variant=variant, reason=Reason.STATIC)
+
+        variant = targeting(flag.key, flag.targeting, evaluation_context)
+
+        if variant is None:
+            variant, value = flag.default
+            return FlagResolutionDetails(value, variant=variant, reason=Reason.DEFAULT)
+        if not isinstance(variant, (str, bool)):
+            raise ParseError(
+                "Parsed JSONLogic targeting did not return a string or bool"
+            )
+
+        variant, value = flag.get_variant(variant)
+        if not value:
+            raise ParseError(f"Resolved variant {variant} not in variants config.")
+
+        return FlagResolutionDetails(
+            value,
+            variant=variant,
+            reason=Reason.TARGETING_MATCH,
+        )

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,106 @@
+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], 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))