openfeature-provider-flagd 0.4.0

OpenFeature provider for the flagd flag evaluation engine

flagd Provider for OpenFeature

This provider is designed to use flagd's evaluation protocol, or locally evaluate flags defined in a flagd flag definition via the OpenFeature Python SDK.

Installation

pip install openfeature-provider-flagd

Configuration and Usage

The flagd provider can operate in two modes: RPC (evaluation takes place in flagd, via gRPC calls) or in-process (evaluation takes place in-process, with the provider getting a ruleset from a compliant sync-source).

Remote resolver (RPC)

This is the default mode of operation of the provider. In this mode, FlagdProvider communicates with flagd via the gRPC protocol. Flag evaluations take place remotely at the connected flagd instance.

Instantiate a new FlagdProvider instance and configure the OpenFeature SDK to use it:

from openfeature import api
from openfeature.contrib.provider.flagd import FlagdProvider

api.set_provider(FlagdProvider())

In-process resolver

This mode performs flag evaluations locally (in-process). Flag configurations for evaluation are obtained via gRPC protocol using sync protobuf schema service definition.

Consider the following example to create a FlagdProvider with in-process evaluations,

from openfeature import api
from openfeature.contrib.provider.flagd import FlagdProvider
from openfeature.contrib.provider.flagd.config import ResolverType

api.set_provider(FlagdProvider(
    resolver_type=ResolverType.IN_PROCESS,
))

In the above example, in-process handlers attempt to connect to a sync service on address localhost:8013 to obtain flag definitions.

File mode

In-process resolvers can also work in an offline mode. To enable this mode, you should provide a valid flag configuration file with the option offlineFlagSourcePath.

from openfeature import api
from openfeature.contrib.provider.flagd import FlagdProvider
from openfeature.contrib.provider.flagd.config import ResolverType

api.set_provider(FlagdProvider(
    resolver_type=ResolverType.FILE,
    offline_flag_source_path="my-flag.json",
))

Provider will attempt to detect file changes using polling. Polling happens at 5 second intervals and this is currently unconfigurable. This mode is useful for local development, tests and offline applications.

Configuration options

The default options can be defined in the FlagdProvider constructor.

Option name	Environment variable name	Type & Values	Default	Compatible resolver
resolver_type	FLAGD_RESOLVER	enum - rpc, in-process	rpc
host	FLAGD_HOST	str	localhost	rpc & in-process
port	FLAGD_PORT	int	8013 (rpc), 8015 (in-process)	rpc & in-process
tls	FLAGD_TLS	bool	false	rpc & in-process
cert_path	FLAGD_SERVER_CERT_PATH	String	null	rpc & in-process
deadline	FLAGD_DEADLINE_MS	int	500	rpc & in-process
stream_deadline_ms	FLAGD_STREAM_DEADLINE_MS	int	600000	rpc & in-process
keep_alive_time	FLAGD_KEEP_ALIVE_TIME_MS	int	0	rpc & in-process
selector	FLAGD_SOURCE_SELECTOR	str	null	in-process
cache_type	FLAGD_CACHE	enum - lru, disabled	lru	rpc
max_cache_size	FLAGD_MAX_CACHE_SIZE	int	1000	rpc
retry_backoff_ms	FLAGD_RETRY_BACKOFF_MS	int	1000	rpc
offline_flag_source_path	FLAGD_OFFLINE_FLAG_SOURCE_PATH	str	null	in-process

[!NOTE] The selector configuration is only used in in-process mode for filtering flag configurations. See Selector Handling for migration guidance.

[!NOTE] Some configurations are only applicable for RPC resolver.

Selector Handling (In-Process Mode Only)

[!IMPORTANT] This section only applies to in-process resolver mode. RPC mode is not affected by selector handling changes.

Current Implementation

As of this SDK version, the selector parameter is passed via both gRPC metadata headers (flagd-selector) and the request body when using in-process mode. This dual approach ensures maximum compatibility with all flagd versions.

Configuration Example:

from openfeature import api
from openfeature.contrib.provider.flagd import FlagdProvider
from openfeature.contrib.provider.flagd.config import ResolverType

api.set_provider(FlagdProvider(
    resolver_type=ResolverType.IN_PROCESS,
    selector="my-flag-source",  # Passed via both header and request body
))

The selector is automatically passed via:

• gRPC metadata header (flagd-selector) - For flagd v0.11.0+ selector normalization
• Request body - For backward compatibility with older flagd versions

Backward Compatibility

This dual transmission approach ensures the Python SDK works seamlessly with all flagd service versions:

• Older flagd versions read the selector from the request body
• Newer flagd versions (v0.11.0+) prefer the selector from the gRPC metadata header
• Both approaches are supported simultaneously for maximum compatibility

Related Resources:

• Upstream issue: open-feature/flagd#1814
• Selector normalization affects in-process evaluations that filter flag configurations by source

Reconnection

Reconnection is supported by the underlying gRPC connections. If the connection to flagd is lost, it will reconnect automatically. A failure to connect will result in an error event from the provider, though it will attempt to reconnect indefinitely.

Deadlines

Deadlines are used to define how long the provider waits to complete initialization or flag evaluations. They behave differently based on the resolver type.

Deadlines with Remote resolver (RPC)

If the remote evaluation call is not completed within this deadline, the gRPC call is terminated with the error DEADLINE_EXCEEDED and the evaluation will default.

TLS

TLS is available in situations where flagd is running on another host.

You may optionally supply an X.509 certificate in PEM format. Otherwise, the default certificate store will be used.

from openfeature import api
from openfeature.contrib.provider.flagd import FlagdProvider

api.set_provider(FlagdProvider(
    tls=True,                        # use TLS
    cert_path="etc/cert/ca.crt"      # PEM cert
))

License

Apache 2.0 - See LICENSE for more information.