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

openfeature/.gitignore

@@ -0,0 +1,2 @@
+
+schemas

openfeature/contrib/provider/flagd/config.py

@@ -1,7 +1,58 @@
+import dataclasses
 import os
 import typing
 from enum import Enum
 
+import grpc
+
+
+class ResolverType(Enum):
+    RPC = "rpc"
+    IN_PROCESS = "in-process"
+    FILE = "file"
+
+
+class CacheType(Enum):
+    LRU = "lru"
+    DISABLED = "disabled"
+
+
+DEFAULT_CACHE = CacheType.LRU
+DEFAULT_CACHE_SIZE = 1000
+DEFAULT_DEADLINE = 500
+DEFAULT_HOST = "localhost"
+DEFAULT_KEEP_ALIVE = 0
+DEFAULT_OFFLINE_SOURCE_PATH: typing.Optional[str] = None
+DEFAULT_OFFLINE_POLL_MS = 5000
+DEFAULT_PORT_IN_PROCESS = 8015
+DEFAULT_PORT_RPC = 8013
+DEFAULT_RESOLVER_TYPE = ResolverType.RPC
+DEFAULT_RETRY_BACKOFF = 1000
+DEFAULT_RETRY_BACKOFF_MAX = 120000
+DEFAULT_RETRY_GRACE_PERIOD_SECONDS = 5
+DEFAULT_STREAM_DEADLINE = 600000
+DEFAULT_TLS = False
+DEFAULT_TLS_CERT: typing.Optional[str] = None
+
+ENV_VAR_CACHE_SIZE = "FLAGD_MAX_CACHE_SIZE"
+ENV_VAR_CACHE_TYPE = "FLAGD_CACHE"
+ENV_VAR_DEADLINE_MS = "FLAGD_DEADLINE_MS"
+ENV_VAR_HOST = "FLAGD_HOST"
+ENV_VAR_KEEP_ALIVE_TIME_MS = "FLAGD_KEEP_ALIVE_TIME_MS"
+ENV_VAR_OFFLINE_FLAG_SOURCE_PATH = "FLAGD_OFFLINE_FLAG_SOURCE_PATH"
+ENV_VAR_OFFLINE_POLL_MS = "FLAGD_OFFLINE_POLL_MS"
+ENV_VAR_PORT = "FLAGD_PORT"
+ENV_VAR_RESOLVER_TYPE = "FLAGD_RESOLVER"
+ENV_VAR_RETRY_BACKOFF_MS = "FLAGD_RETRY_BACKOFF_MS"
+ENV_VAR_RETRY_BACKOFF_MAX_MS = "FLAGD_RETRY_BACKOFF_MAX_MS"
+ENV_VAR_RETRY_GRACE_PERIOD_SECONDS = "FLAGD_RETRY_GRACE_PERIOD"
+ENV_VAR_SELECTOR = "FLAGD_SOURCE_SELECTOR"
+ENV_VAR_PROVIDER_ID = "FLAGD_SOURCE_PROVIDER_ID"
+ENV_VAR_STREAM_DEADLINE_MS = "FLAGD_STREAM_DEADLINE_MS"
+ENV_VAR_TLS = "FLAGD_TLS"
+ENV_VAR_TLS_CERT = "FLAGD_SERVER_CERT_PATH"
+ENV_VAR_DEFAULT_AUTHORITY = "FLAGD_DEFAULT_AUTHORITY"
+
 T = typing.TypeVar("T")
 
 
@@ -9,6 +60,14 @@ def str_to_bool(val: str) -> bool:
     return val.lower() == "true"
 
 
+def convert_resolver_type(val: typing.Union[str, ResolverType]) -> ResolverType:
+    if isinstance(val, str):
+        v = val.lower()
+        return ResolverType(v)
+    else:
+        return ResolverType(val)
+
+
 def env_or_default(
     env_var: str, default: T, cast: typing.Optional[typing.Callable[[str], T]] = None
 ) -> typing.Union[str, T]:
@@ -18,42 +77,174 @@ def env_or_default(
     return val if cast is None else cast(val)
 
 
-class ResolverType(Enum):
-    GRPC = "grpc"
-    IN_PROCESS = "in-process"
-
-
+@dataclasses.dataclass
 class Config:
     def __init__(  # noqa: PLR0913
         self,
         host: typing.Optional[str] = None,
         port: typing.Optional[int] = None,
         tls: typing.Optional[bool] = None,
-        timeout: typing.Optional[int] = None,
-        resolver_type: typing.Optional[ResolverType] = None,
+        selector: typing.Optional[str] = None,
+        provider_id: typing.Optional[str] = None,
+        resolver: typing.Optional[ResolverType] = None,
         offline_flag_source_path: typing.Optional[str] = None,
-        offline_poll_interval_seconds: typing.Optional[float] = None,
+        offline_poll_interval_ms: typing.Optional[int] = None,
+        retry_backoff_ms: typing.Optional[int] = None,
+        retry_backoff_max_ms: typing.Optional[int] = None,
+        retry_grace_period: typing.Optional[int] = None,
+        deadline_ms: typing.Optional[int] = None,
+        stream_deadline_ms: typing.Optional[int] = None,
+        keep_alive_time: typing.Optional[int] = None,
+        cache: typing.Optional[CacheType] = None,
+        max_cache_size: typing.Optional[int] = None,
+        cert_path: typing.Optional[str] = None,
+        default_authority: typing.Optional[str] = None,
+        channel_credentials: typing.Optional[grpc.ChannelCredentials] = None,
     ):
-        self.host = env_or_default("FLAGD_HOST", "localhost") if host is None else host
-        self.port = (
-            env_or_default("FLAGD_PORT", 8013, cast=int) if port is None else port
-        )
+        self.host = env_or_default(ENV_VAR_HOST, DEFAULT_HOST) if host is None else host
+
         self.tls = (
-            env_or_default("FLAGD_TLS", False, cast=str_to_bool) if tls is None else tls
+            env_or_default(ENV_VAR_TLS, DEFAULT_TLS, cast=str_to_bool)
+            if tls is None
+            else tls
+        )
+
+        self.retry_backoff_ms: int = (
+            int(
+                env_or_default(
+                    ENV_VAR_RETRY_BACKOFF_MS, DEFAULT_RETRY_BACKOFF, cast=int
+                )
+            )
+            if retry_backoff_ms is None
+            else retry_backoff_ms
         )
-        self.timeout = 5 if timeout is None else timeout
-        self.resolver_type = (
-            ResolverType(env_or_default("FLAGD_RESOLVER_TYPE", "grpc"))
-            if resolver_type is None
-            else resolver_type
+        self.retry_backoff_max_ms: int = (
+            int(
+                env_or_default(
+                    ENV_VAR_RETRY_BACKOFF_MAX_MS, DEFAULT_RETRY_BACKOFF_MAX, cast=int
+                )
+            )
+            if retry_backoff_max_ms is None
+            else retry_backoff_max_ms
+        )
+
+        self.retry_grace_period: int = (
+            int(
+                env_or_default(
+                    ENV_VAR_RETRY_GRACE_PERIOD_SECONDS,
+                    DEFAULT_RETRY_GRACE_PERIOD_SECONDS,
+                    cast=int,
+                )
+            )
+            if retry_grace_period is None
+            else retry_grace_period
+        )
+
+        self.resolver = (
+            env_or_default(
+                ENV_VAR_RESOLVER_TYPE, DEFAULT_RESOLVER_TYPE, cast=convert_resolver_type
+            )
+            if resolver is None
+            else resolver
+        )
+
+        default_port = (
+            DEFAULT_PORT_RPC
+            if self.resolver is ResolverType.RPC
+            else DEFAULT_PORT_IN_PROCESS
         )
+
+        self.port: int = (
+            int(env_or_default(ENV_VAR_PORT, default_port, cast=int))
+            if port is None
+            else port
+        )
+
         self.offline_flag_source_path = (
-            env_or_default("FLAGD_OFFLINE_FLAG_SOURCE_PATH", None)
+            env_or_default(
+                ENV_VAR_OFFLINE_FLAG_SOURCE_PATH, DEFAULT_OFFLINE_SOURCE_PATH
+            )
             if offline_flag_source_path is None
             else offline_flag_source_path
         )
-        self.offline_poll_interval_seconds = (
-            float(env_or_default("FLAGD_OFFLINE_POLL_INTERVAL_SECONDS", 1.0))
-            if offline_poll_interval_seconds is None
-            else offline_poll_interval_seconds
+
+        if (
+            self.offline_flag_source_path is not None
+            and self.resolver is ResolverType.IN_PROCESS
+        ):
+            self.resolver = ResolverType.FILE
+
+        if self.resolver is ResolverType.FILE and self.offline_flag_source_path is None:
+            raise AttributeError(
+                "Resolver Type 'FILE' requires a offlineFlagSourcePath"
+            )
+
+        self.offline_poll_interval_ms: int = (
+            int(
+                env_or_default(
+                    ENV_VAR_OFFLINE_POLL_MS, DEFAULT_OFFLINE_POLL_MS, cast=int
+                )
+            )
+            if offline_poll_interval_ms is None
+            else offline_poll_interval_ms
         )
+
+        self.deadline_ms: int = (
+            int(env_or_default(ENV_VAR_DEADLINE_MS, DEFAULT_DEADLINE, cast=int))
+            if deadline_ms is None
+            else deadline_ms
+        )
+
+        self.stream_deadline_ms: int = (
+            int(
+                env_or_default(
+                    ENV_VAR_STREAM_DEADLINE_MS, DEFAULT_STREAM_DEADLINE, cast=int
+                )
+            )
+            if stream_deadline_ms is None
+            else stream_deadline_ms
+        )
+
+        self.keep_alive_time: int = (
+            int(
+                env_or_default(ENV_VAR_KEEP_ALIVE_TIME_MS, DEFAULT_KEEP_ALIVE, cast=int)
+            )
+            if keep_alive_time is None
+            else keep_alive_time
+        )
+
+        self.cache = (
+            CacheType(env_or_default(ENV_VAR_CACHE_TYPE, DEFAULT_CACHE))
+            if cache is None
+            else cache
+        )
+
+        self.max_cache_size: int = (
+            int(env_or_default(ENV_VAR_CACHE_SIZE, DEFAULT_CACHE_SIZE, cast=int))
+            if max_cache_size is None
+            else max_cache_size
+        )
+
+        self.cert_path = (
+            env_or_default(ENV_VAR_TLS_CERT, DEFAULT_TLS_CERT)
+            if cert_path is None
+            else cert_path
+        )
+
+        self.selector = (
+            env_or_default(ENV_VAR_SELECTOR, None) if selector is None else selector
+        )
+
+        self.provider_id = (
+            env_or_default(ENV_VAR_PROVIDER_ID, None)
+            if provider_id is None
+            else provider_id
+        )
+
+        self.default_authority = (
+            env_or_default(ENV_VAR_DEFAULT_AUTHORITY, None)
+            if default_authority is None
+            else default_authority
+        )
+
+        self.channel_credentials = channel_credentials

openfeature/contrib/provider/flagd/provider.py

@@ -22,14 +22,20 @@
 """
 
 import typing
+import warnings
+
+import grpc
 
 from openfeature.evaluation_context import EvaluationContext
+from openfeature.event import ProviderEventDetails
 from openfeature.flag_evaluation import FlagResolutionDetails
+from openfeature.hook import Hook
+from openfeature.provider import AbstractProvider
 from openfeature.provider.metadata import Metadata
-from openfeature.provider.provider import AbstractProvider
 
-from .config import Config, ResolverType
+from .config import CacheType, Config, ResolverType
 from .resolvers import AbstractResolver, GrpcResolver, InProcessResolver
+from .sync_metadata_hook import SyncMetadataHook
 
 T = typing.TypeVar("T")
 
@@ -42,10 +48,22 @@ class FlagdProvider(AbstractProvider):
         host: typing.Optional[str] = None,
         port: typing.Optional[int] = None,
         tls: typing.Optional[bool] = None,
+        deadline_ms: typing.Optional[int] = None,
         timeout: typing.Optional[int] = None,
+        retry_backoff_ms: typing.Optional[int] = None,
+        selector: typing.Optional[str] = None,
+        provider_id: typing.Optional[str] = None,
         resolver_type: typing.Optional[ResolverType] = None,
         offline_flag_source_path: typing.Optional[str] = None,
-        offline_poll_interval_seconds: typing.Optional[float] = None,
+        stream_deadline_ms: typing.Optional[int] = None,
+        keep_alive_time: typing.Optional[int] = None,
+        cache: typing.Optional[CacheType] = None,
+        max_cache_size: typing.Optional[int] = None,
+        retry_backoff_max_ms: typing.Optional[int] = None,
+        retry_grace_period: typing.Optional[int] = None,
+        cert_path: typing.Optional[str] = None,
+        default_authority: typing.Optional[str] = None,
+        channel_credentials: typing.Optional[grpc.ChannelCredentials] = None,
     ):
         """
         Create an instance of the FlagdProvider
@@ -53,30 +71,81 @@ class FlagdProvider(AbstractProvider):
         :param host: the host to make requests to
         :param port: the port the flagd service is available on
         :param tls: enable/disable secure TLS connectivity
-        :param timeout: the maximum to wait before a request times out
+        :param deadline_ms: the maximum to wait before a request times out
+        :param timeout: the maximum time to wait before a request times out
+        :param retry_backoff_ms: the number of milliseconds to backoff
+        :param offline_flag_source_path: the path to the flag source file
+        :param stream_deadline_ms: the maximum time to wait before a request times out
+        :param keep_alive_time: the number of milliseconds to keep alive
+        :param resolver_type: the type of resolver to use
         """
+        if deadline_ms is None and timeout is not None:
+            deadline_ms = timeout * 1000
+            warnings.warn(
+                "'timeout' property is deprecated, please use 'deadline' instead, be aware that 'deadline' is in milliseconds",
+                DeprecationWarning,
+                stacklevel=2,
+            )
+
         self.config = Config(
             host=host,
             port=port,
             tls=tls,
-            timeout=timeout,
-            resolver_type=resolver_type,
+            deadline_ms=deadline_ms,
+            retry_backoff_ms=retry_backoff_ms,
+            retry_backoff_max_ms=retry_backoff_max_ms,
+            retry_grace_period=retry_grace_period,
+            selector=selector,
+            provider_id=provider_id,
+            resolver=resolver_type,
             offline_flag_source_path=offline_flag_source_path,
-            offline_poll_interval_seconds=offline_poll_interval_seconds,
+            stream_deadline_ms=stream_deadline_ms,
+            keep_alive_time=keep_alive_time,
+            cache=cache,
+            max_cache_size=max_cache_size,
+            cert_path=cert_path,
+            default_authority=default_authority,
+            channel_credentials=channel_credentials,
         )
+        self.enriched_context: dict = {}
 
         self.resolver = self.setup_resolver()
+        self.hooks: list[Hook] = [SyncMetadataHook(self.get_enriched_context)]
+
+    def get_enriched_context(self) -> EvaluationContext:
+        return EvaluationContext(attributes=self.enriched_context)
+
+    def get_provider_hooks(self) -> list[Hook]:
+        return self.hooks
 
     def setup_resolver(self) -> AbstractResolver:
-        if self.config.resolver_type == ResolverType.GRPC:
-            return GrpcResolver(self.config)
-        elif self.config.resolver_type == ResolverType.IN_PROCESS:
-            return InProcessResolver(self.config, self)
+        if self.config.resolver == ResolverType.RPC:
+            return GrpcResolver(
+                self.config,
+                self.emit_provider_ready,
+                self.emit_provider_error,
+                self.emit_provider_stale,
+                self.emit_provider_configuration_changed,
+            )
+        elif (
+            self.config.resolver == ResolverType.IN_PROCESS
+            or self.config.resolver == ResolverType.FILE
+        ):
+            return InProcessResolver(
+                self.config,
+                self.emit_provider_ready_with_context,
+                self.emit_provider_error,
+                self.emit_provider_stale,
+                self.emit_provider_configuration_changed,
+            )
         else:
             raise ValueError(
-                f"`resolver_type` parameter invalid: {self.config.resolver_type}"
+                f"`resolver_type` parameter invalid: {self.config.resolver}"
             )
 
+    def initialize(self, evaluation_context: EvaluationContext) -> None:
+        self.resolver.initialize(evaluation_context)
+
     def shutdown(self) -> None:
         if self.resolver:
             self.resolver.shutdown()
@@ -134,3 +203,10 @@ class FlagdProvider(AbstractProvider):
         return self.resolver.resolve_object_details(
             key, default_value, evaluation_context
         )
+
+    def emit_provider_ready_with_context(
+        self, details: ProviderEventDetails, context: dict
+    ) -> None:
+        self.enriched_context = context
+        self.emit_provider_ready(details)
+        pass

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

@@ -1,51 +1,5 @@
-import typing
-
-from typing_extensions import Protocol
-
-from openfeature.evaluation_context import EvaluationContext
-from openfeature.flag_evaluation import FlagResolutionDetails
-
 from .grpc import GrpcResolver
 from .in_process import InProcessResolver
-
-
-class AbstractResolver(Protocol):
-    def shutdown(self) -> None: ...
-
-    def resolve_boolean_details(
-        self,
-        key: str,
-        default_value: bool,
-        evaluation_context: typing.Optional[EvaluationContext] = None,
-    ) -> FlagResolutionDetails[bool]: ...
-
-    def resolve_string_details(
-        self,
-        key: str,
-        default_value: str,
-        evaluation_context: typing.Optional[EvaluationContext] = None,
-    ) -> FlagResolutionDetails[str]: ...
-
-    def resolve_float_details(
-        self,
-        key: str,
-        default_value: float,
-        evaluation_context: typing.Optional[EvaluationContext] = None,
-    ) -> FlagResolutionDetails[float]: ...
-
-    def resolve_integer_details(
-        self,
-        key: str,
-        default_value: int,
-        evaluation_context: typing.Optional[EvaluationContext] = None,
-    ) -> FlagResolutionDetails[int]: ...
-
-    def resolve_object_details(
-        self,
-        key: str,
-        default_value: typing.Union[dict, list],
-        evaluation_context: typing.Optional[EvaluationContext] = None,
-    ) -> FlagResolutionDetails[typing.Union[dict, list]]: ...
-
+from .protocol import AbstractResolver
 
 __all__ = ["AbstractResolver", "GrpcResolver", "InProcessResolver"]