Add global flag evaluation; drop logged-out-context hack in update_badges

Add module-level get_boolean_value / get_string_value / ... to experimentation
for evaluating flags with no user/request context (anonymous, like a logged-out
user). The enabled / pass-all-gates gating moves into shared helpers that both
the new global functions and CouchersContext use - the context keeps its cached
per-request evaluator by passing it in.

update_badges now calls experimentation.get_boolean_value directly instead of
constructing a throwaway logged-out CouchersContext just to read a flag.

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>

Author: aapeliv

app/backend/src/couchers/context.py

@@ -3,7 +3,6 @@
 import grpc
 
 from couchers import experimentation
-from couchers.config import config
 from couchers.i18n import LocalizationContext
 
 if TYPE_CHECKING:
@@ -181,29 +180,23 @@ def token(self) -> str:
     def localization(self) -> LocalizationContext:
         return self.__localization
 
-    # Feature-flag evaluation methods mirror the OpenFeature evaluation API. The in-code default is
-    # honored even for flags not yet set up in GrowthBook, since get_feature_value falls back to it.
+    # Feature-flag evaluation methods mirror the OpenFeature evaluation API, evaluating for this
+    # context's user. The gating lives in experimentation; we just pass our cached per-request
+    # evaluator. The in-code default is honored even for flags not yet set up in GrowthBook.
     def get_boolean_value(self, flag_key: str, default: bool) -> bool:
-        if config["EXPERIMENTATION_PASS_ALL_GATES"]:
-            return True
-        return self._get_feature_value(flag_key, default)
+        return experimentation._boolean_value(flag_key, default, self._get_growthbook)
 
     def get_string_value(self, flag_key: str, default: str) -> str:
-        return self._get_feature_value(flag_key, default)
+        return experimentation._feature_value(flag_key, default, self._get_growthbook)
 
     def get_integer_value(self, flag_key: str, default: int) -> int:
-        return self._get_feature_value(flag_key, default)
+        return experimentation._feature_value(flag_key, default, self._get_growthbook)
 
     def get_float_value(self, flag_key: str, default: float) -> float:
-        return self._get_feature_value(flag_key, default)
+        return experimentation._feature_value(flag_key, default, self._get_growthbook)
 
     def get_object_value[T](self, flag_key: str, default: T) -> T:
-        return self._get_feature_value(flag_key, default)
-
-    def _get_feature_value[T](self, flag_key: str, default: T) -> T:
-        if not config["EXPERIMENTATION_ENABLED"]:
-            return default
-        return self._get_growthbook().get_feature_value(flag_key, default)  # type: ignore[no-any-return]
+        return experimentation._feature_value(flag_key, default, self._get_growthbook)
 
     def _get_growthbook(self) -> GrowthBook:
         if self._growthbook is None:

app/backend/src/couchers/experimentation.py

@@ -3,15 +3,20 @@
 
 Uses GrowthBook under the hood, but abstracts the implementation details.
 
-Don't evaluate flags by calling into this module directly - go through the CouchersContext methods
-(context.get_boolean_value, get_string_value, etc.), which own the per-request evaluator cache and
-the enabled / pass-all-gates gating. The underscore-prefixed helpers here are internal to that
-wiring; setup_experimentation() is the only public entry point, called once at process startup.
+Two ways to evaluate a flag:
+  - Per-user/request: use the CouchersContext methods (context.get_boolean_value, get_string_value,
+    etc.), which evaluate for the context's user and own the per-request evaluator cache.
+  - Global (no user/request): use the module-level get_boolean_value / get_string_value / ... below.
+    These evaluate anonymously and are for background jobs and other code with no CouchersContext.
+
+Both paths share the enabled / pass-all-gates gating helpers here. setup_experimentation() is called
+once at process startup.
 """
 
 import json
 import logging
 import threading
+from collections.abc import Callable
 from typing import Any
 
 import urllib3
@@ -170,3 +175,46 @@ def on_experiment_viewed(experiment: Experiment, result: Result, **kwargs: Any)
         savedGroups=saved_groups,
         on_experiment_viewed=on_experiment_viewed,
     )
+
+
+def _global_evaluator() -> GrowthBook:
+    """Build an anonymous evaluator for flag evaluation with no user/request context."""
+    return _create_evaluator(None)
+
+
+# These two helpers are the single home of the gating logic, shared by the global functions below
+# and by CouchersContext (which passes its own cached per-request evaluator). get_evaluator is only
+# invoked once gating passes, so it stays lazy.
+def _feature_value[T](flag_key: str, default: T, get_evaluator: Callable[[], GrowthBook]) -> T:
+    if not config["EXPERIMENTATION_ENABLED"]:
+        return default
+    return get_evaluator().get_feature_value(flag_key, default)  # type: ignore[no-any-return]
+
+
+def _boolean_value(flag_key: str, default: bool, get_evaluator: Callable[[], GrowthBook]) -> bool:
+    if config["EXPERIMENTATION_PASS_ALL_GATES"]:
+        return True
+    return _feature_value(flag_key, default, get_evaluator)
+
+
+# Global (no user/request) flag evaluation. Mirrors the CouchersContext.get_*_value API but
+# evaluates anonymously: experiments and percentage rollouts are skipped (no user to bucket), so
+# flags fall through to their in-code defaults unless a rule forces a value globally.
+def get_boolean_value(flag_key: str, default: bool) -> bool:
+    return _boolean_value(flag_key, default, _global_evaluator)
+
+
+def get_string_value(flag_key: str, default: str) -> str:
+    return _feature_value(flag_key, default, _global_evaluator)
+
+
+def get_integer_value(flag_key: str, default: int) -> int:
+    return _feature_value(flag_key, default, _global_evaluator)
+
+
+def get_float_value(flag_key: str, default: float) -> float:
+    return _feature_value(flag_key, default, _global_evaluator)
+
+
+def get_object_value[T](flag_key: str, default: T) -> T:
+    return _feature_value(flag_key, default, _global_evaluator)

app/backend/src/couchers/jobs/handlers.py

@@ -29,6 +29,7 @@
     update,
 )
 
+from couchers import experimentation
 from couchers.config import config
 from couchers.constants import (
     ACTIVENESS_PROBE_EXPIRY_TIME,
@@ -38,7 +39,7 @@
     HOST_REQUEST_MAX_REMINDERS,
     HOST_REQUEST_REMINDER_INTERVAL,
 )
-from couchers.context import make_background_user_context, make_logged_out_context
+from couchers.context import make_background_user_context
 from couchers.crypto import (
     USER_LOCATION_RANDOMIZATION_NAME,
     asym_encrypt,
@@ -53,7 +54,6 @@
 from couchers.event_log import log_event
 from couchers.helpers.badges import user_add_badge, user_remove_badge
 from couchers.helpers.completed_profile import has_completed_profile_expression
-from couchers.i18n import LocalizationContext
 from couchers.materialized_views import (
     UserResponseRate,
 )
@@ -836,12 +836,11 @@ def float_(stmt: Any) -> Function[float]:
 
 def update_badges(payload: empty_pb2.Empty) -> None:
     with session_scope() as session:
-        # feature flags that gate a badge are evaluated globally (no per-user request here)
-        flag_context = make_logged_out_context(LocalizationContext.en_utc())
 
         def update_badge(badge_id: str, members: Sequence[int]) -> None:
             badge = get_badge_dict()[badge_id]
-            if badge.flag is not None and not flag_context.get_boolean_value(badge.flag, default=True):
+            # a flag that gates a badge is evaluated globally (no per-user request here)
+            if badge.flag is not None and not experimentation.get_boolean_value(badge.flag, default=True):
                 members = []
             user_ids = session.execute(select(UserBadge.user_id).where(UserBadge.badge_id == badge.id)).scalars().all()
             # in case the user ids don't exist in the db

app/backend/src/tests/test_experimentation.py

@@ -41,3 +41,16 @@ def test_anonymous_user_still_gets_global_force_on_flag(experimentation_snapshot
 def test_unknown_feature_returns_in_code_default(experimentation_snapshot):
     context = make_logged_out_context(LocalizationContext.en_utc())
     assert context.get_string_value("does_not_exist", "my_default") == "my_default"
+
+
+def test_global_evaluation_excluded_from_rollout_gets_feature_default(experimentation_snapshot):
+    # global (no-user) evaluation can't bucket into a rollout, so it gets the feature default
+    assert experimentation.get_string_value("rollout_flag", "fallback") == "control"
+
+
+def test_global_evaluation_gets_global_force_on_flag(experimentation_snapshot):
+    assert experimentation.get_boolean_value("global_flag", default=False) is True
+
+
+def test_global_evaluation_unknown_feature_returns_in_code_default(experimentation_snapshot):
+    assert experimentation.get_string_value("does_not_exist", "my_default") == "my_default"