GO Feature Flag Python Provider

GO Feature Flag provider allows you to connect to your GO Feature Flag instance.

GO Feature Flag believes in simplicity and offers a simple and lightweight solution to use feature flags.
Our focus is to avoid any complex infrastructure work to use GO Feature Flag.

This is a complete feature flagging solution with the possibility to target only a group of users, use any types of flags, store your configuration in various location and advanced rollout functionality. You can also collect usage data of your flags and be notified of configuration changes.

Python SDK usage

Install dependencies

The first things we will do is install the Open Feature SDK and the GO Feature Flag provider.

pip install gofeatureflag-python-provider

Evaluation modes

The provider supports two evaluation modes:

Initialize your Open Feature client

In-Process evaluation (default)

In-Process evaluation fetches the flag configuration from the relay proxy at startup and on a configurable polling interval. Flags are evaluated locally using a bundled WASM module, which gives you lower latency and no per-evaluation network dependency.

from gofeatureflag_python_provider.provider import GoFeatureFlagProvider
from gofeatureflag_python_provider.options import GoFeatureFlagOptions, EvaluationType
from openfeature import api
from openfeature.evaluation_context import EvaluationContext

goff_provider = GoFeatureFlagProvider(
    options=GoFeatureFlagOptions(
        endpoint="https://gofeatureflag.org/",
        evaluation_type=EvaluationType.INPROCESS,  # default
    )
)
api.set_provider(goff_provider)
client = api.get_client(domain="test-client")

Remote evaluation

Remote evaluation sends each flag evaluation as an HTTP request to the relay proxy.

from gofeatureflag_python_provider.provider import GoFeatureFlagProvider
from gofeatureflag_python_provider.options import GoFeatureFlagOptions, EvaluationType
from openfeature import api

goff_provider = GoFeatureFlagProvider(
    options=GoFeatureFlagOptions(
        endpoint="https://gofeatureflag.org/",
        evaluation_type=EvaluationType.REMOTE,
    )
)
api.set_provider(goff_provider)
client = api.get_client(domain="test-client")

Evaluate your flag

This code block explains how you can create an EvaluationContext and use it to evaluate your flag.

In this example we are evaluating a boolean flag, but other types are available.

Refer to the Open Feature documentation to know more about it.

# Context of your flag evaluation.
# With GO Feature Flag you MUST have a targetingKey that is a unique identifier of the user.
evaluation_ctx = EvaluationContext(
    targeting_key="d45e303a-38c2-11ed-a261-0242ac120002",
    attributes={
        "email": "john.doe@gofeatureflag.org",
        "firstname": "john",
        "lastname": "doe",
        "anonymous": False,
        "professional": True,
        "rate": 3.14,
        "age": 30,
        "company_info": {"name": "my_company", "size": 120},
        "labels": ["pro", "beta"],
    },
)

admin_flag = client.get_boolean_value(
    flag_key="flag-only-for-admin",
    default_value=False,
    evaluation_context=evaluation_ctx,
)

if admin_flag:
    # flag "flag-only-for-admin" is true for the user
    pass
else:
    # flag "flag-only-for-admin" is false for the user
    pass

Configuration options

Usage analytics are collected only while the provider is running — between initialize() (called for you by set_provider) and shutdown(). Evaluations outside that window are not recorded: no flush runs to deliver them, and a buffer left to fill would post to the collector after shutdown() reported it was done. Each such period logs one warning, and the number of events dropped is reported if the provider is started again.

Logging

Every module logs through the standard library under the gofeatureflag_python_provider logger, with one child logger per module (gofeatureflag_python_provider.wasm.evaluate_wasm, gofeatureflag_python_provider.services.event_publisher, and so on). Attach your handler to the package logger to capture all of it:

import logging

logging.getLogger("gofeatureflag_python_provider").setLevel(logging.INFO)
logging.getLogger("gofeatureflag_python_provider").addHandler(logging.StreamHandler())

The provider ships a NullHandler on that logger, so it stays silent until your application configures logging.

Two things worth knowing:

• log_level yields to your configuration. The provider applies it to the package logger only when nothing has set a level there yet, because that level is process-wide state. If you configure the logger yourself (directly or through logging.config.dictConfig), your setting wins. If several providers are created with different log_level values, the first one applies.
• Exceptions raised inside hooks are logged by the OpenFeature SDK, under its own openfeature logger, not this one. log_level does not affect them — configure logging.getLogger("openfeature") if you need to see them.

Conformance

This provider targets version 1.0 of the GO Feature Flag Provider Specification, exposed as gofeatureflag_python_provider.__specification_version__.

The evaluation engine it is pinned to is recorded in gofeatureflag_python_provider/wasm/_wasi_version.txt, which is the single source of truth for the bundled WASI binary version.