Skip to content

:hedgehog: PostHog is the leading platform for building self-driving products. Our developer tools – AI observability, analytics, session replay, flags, experiments, error tracking, logs, and more – capture all the context agents need to diagnose problems, uncover opportunities, and ship fixes. Steer it all from Slack, web, desktop, or the MCP.

feat: suggest $feature/ values from the flag definition (#124448)

Andy Zhaod381c760bde5
diff --git a/posthog/hogql_queries/property_values_query_runner.py b/posthog/hogql_queries/property_values_query_runner.py
index bfbc1c302c22..8995bb380443 100644
--- a/posthog/hogql_queries/property_values_query_runner.py
+++ b/posthog/hogql_queries/property_values_query_runner.py
@@ -17,6 +17,7 @@ from posthog.schema import (
)
from posthog.hogql import ast
+from posthog.hogql.constants import FEATURE_FLAG_PROPERTY_PREFIX
from posthog.hogql.parser import parse_expr, parse_select
from posthog.hogql.query import execute_hogql_query
@@ -31,6 +32,10 @@ from posthog.models.event.new_events_schema import use_new_events_schema
from posthog.utils import convert_property_value, flatten, get_instance_region, relative_date_parse
from products.access_control.backend.property_access_control import get_restricted_property_names
+from products.feature_flags.backend.facade.property_values import (
+ flag_property_values_revision,
+ get_flag_property_values,
+)
PROPERTY_VALUES_TABLE_FLAG = "property-values-table"
@@ -67,6 +72,8 @@ class PropertyValuesQueryRunner(AnalyticsQueryRunner[PropertyValuesQueryResponse
timings=self.timings.to_list(),
modifiers=self.modifiers,
)
+ if self._feature_flag_property_values is not None:
+ return self._calculate_event_from_flag(self._feature_flag_property_values)
if self._use_property_values_table:
return self._calculate_event_from_table()
result = execute_hogql_query(
@@ -101,13 +108,41 @@ class PropertyValuesQueryRunner(AnalyticsQueryRunner[PropertyValuesQueryResponse
team_id=self.team.pk, user=self.user, property_type=PropertyDefinition.Type.EVENT
)
+ @cached_property
+ def _feature_flag_key(self) -> str | None:
+ key = self.query.property_key
+ if (
+ self.query.property_type != PropertyType.EVENT
+ or self.query.is_column
+ or not key.startswith(FEATURE_FLAG_PROPERTY_PREFIX)
+ ):
+ return None
+ return key.removeprefix(FEATURE_FLAG_PROPERTY_PREFIX)
+
+ @cached_property
+ def _feature_flag_property_values(self) -> list[bool | str] | None:
+ if self._feature_flag_key is None:
+ return None
+ return get_flag_property_values(self.team, self._feature_flag_key)
+
+ def _calculate_event_from_flag(self, values: list[bool | str]) -> PropertyValuesQueryResponse:
+ search = (self.query.search_value or "").lower()
+ names = list(dict.fromkeys(convert_property_value(value) for value in values))
+ return PropertyValuesQueryResponse(
+ results=[PropertyValueItem(name=name) for name in names if search in name.lower()],
+ timings=self.timings.to_list(),
+ modifiers=self.modifiers,
+ )
+
@cached_property
def _use_property_values_table(self) -> bool:
# Column and virtual lookups stay on the events scan: the table only
- # holds keys from the properties blob. event_names is deliberately not
- # a fallback: the table has no event dimension, so flagged teams get
- # event-agnostic value suggestions for event-scoped requests.
- if self.query.is_column or self.query.property_key.startswith("$virt_"):
+ # holds keys from the properties blob. `$feature/` lookups stay there
+ # too, because property-vals-rs can be set to skip `$feature/` keys.
+ # event_names is deliberately not a fallback: the table has no event
+ # dimension, so flagged teams get event-agnostic value suggestions for
+ # event-scoped requests.
+ if self.query.is_column or self.query.property_key.startswith(("$virt_", FEATURE_FLAG_PROPERTY_PREFIX)):
return False
team_id = str(self.team.pk)
if not posthoganalytics.feature_enabled(
@@ -182,6 +217,9 @@ class PropertyValuesQueryRunner(AnalyticsQueryRunner[PropertyValuesQueryResponse
# Person values cached before the HogQL port were computed without property
# masking; the version marker keeps them from being served.
payload["property_values_version"] = 2
+ # A cached answer must not outlive a flag edit or a new access rule on the flag.
+ if self._feature_flag_key is not None:
+ payload["feature_flag_revision"] = flag_property_values_revision(self.team, self._feature_flag_key)
return payload
def _person_query(self) -> ast.SelectQuery:
diff --git a/posthog/hogql_queries/test/test_property_values_query_runner.py b/posthog/hogql_queries/test/test_property_values_query_runner.py
index 81eecf27eca2..3686980bab0d 100644
--- a/posthog/hogql_queries/test/test_property_values_query_runner.py
+++ b/posthog/hogql_queries/test/test_property_values_query_runner.py
@@ -17,6 +17,7 @@ from parameterized import parameterized
from posthog.hogql.query import execute_hogql_query
from posthog.clickhouse.client import sync_execute
+from posthog.constants import AvailableFeature
from posthog.hogql_queries.property_values_query_runner import (
PROPERTY_VALUES_TABLE_FLAG,
CachedPropertyValuesQueryResponse,
@@ -26,6 +27,33 @@ from posthog.hogql_queries.property_values_query_runner import (
PropertyValuesQueryRunner,
)
from posthog.hogql_queries.query_runner import ExecutionMode
+from posthog.models import Organization, Team
+
+from products.access_control.backend.facade.testing import create_access_control
+from products.feature_flags.backend.models.feature_flag import FeatureFlag
+
+
+def variant_filters(*keys: str) -> dict:
+ return {
+ "groups": [{"rollout_percentage": 100}],
+ "multivariate": {"variants": [{"key": key, "rollout_percentage": 100 // len(keys)} for key in keys]},
+ }
+
+
+def string_flag_filters(default_value: str, *rule_values: str) -> dict:
+ rules = [
+ {"id": f"rule-{value}", "rule_type": "targeted_release", "targeting": {"properties": []}, "value": value}
+ for value in rule_values
+ ]
+ return {"version": 2, "return_type": "string", "default_value": default_value, "rules": rules}
+
+
+MULTIVARIATE_FILTERS = {
+ "groups": [{"rollout_percentage": 100}],
+ "multivariate": {
+ "variants": [{"key": "control", "rollout_percentage": 50}, {"key": "test", "rollout_percentage": 50}]
+ },
+}
class TestPropertyValuesQueryRunner(ClickhouseTestMixin, APIBaseTest):
@@ -33,6 +61,12 @@ class TestPropertyValuesQueryRunner(ClickhouseTestMixin, APIBaseTest):
runner = PropertyValuesQueryRunner(team=self.team, query=query)
return runner.calculate().results
+ def _run_cached(self, query: PropertyValuesQuery) -> list[PropertyValueItem]:
+ runner = PropertyValuesQueryRunner(team=self.team, query=query)
+ response = runner.run(ExecutionMode.RECENT_CACHE_CALCULATE_ASYNC_IF_STALE_AND_BLOCKING_ON_MISS)
+ assert isinstance(response, CachedPropertyValuesQueryResponse)
+ return response.results
+
def test_event_property_values_basic(self):
_create_event(event="$pageview", distinct_id="u1", team=self.team, properties={"browser": "Chrome"})
_create_event(event="$pageview", distinct_id="u2", team=self.team, properties={"browser": "Firefox"})
@@ -143,6 +177,154 @@ class TestPropertyValuesQueryRunner(ClickhouseTestMixin, APIBaseTest):
results = self._run(PropertyValuesQuery(property_type=PropertyType.EVENT, property_key="browser"))
assert results[0].count is None
+ @parameterized.expand(
+ [
+ ("boolean_flag", {"groups": [{"rollout_percentage": 100}]}, None, ["true", "false"]),
+ ("multivariate_flag", MULTIVARIATE_FILTERS, None, ["control", "test", "true", "false"]),
+ ("search_is_case_insensitive", MULTIVARIATE_FILTERS, "TES", ["test"]),
+ ("variant_named_true", variant_filters("true", "off"), None, ["true", "off", "false"]),
+ (
+ "holdout",
+ {**MULTIVARIATE_FILTERS, "holdout": {"id": 42, "exclusion_percentage": 10}},
+ None,
+ ["control", "test", "holdout-42", "true", "false"],
+ ),
+ ("deleted_flag", MULTIVARIATE_FILTERS, None, ["control", "test", "true", "false"], "kept_key"),
+ (
+ "deleted_flag_with_tombstoned_key",
+ MULTIVARIATE_FILTERS,
+ None,
+ ["control", "test", "true", "false"],
+ "tombstoned_key",
+ ),
+ ]
+ )
+ def test_feature_flag_property_values_come_from_the_flag(
+ self, _name, filters, search_value, expected_names, deletion=None
+ ):
+ flag = FeatureFlag.objects.create(
+ team=self.team, key="beta", created_by=self.user, filters=filters, deleted=deletion is not None
+ )
+ if deletion == "tombstoned_key":
+ flag.key = flag.tombstoned_key()
+ flag.save()
+ _create_event(event="$pageview", distinct_id="u1", team=self.team, properties={"$feature/beta": "retired"})
+ flush_persons_and_events()
+
+ results = self._run(
+ PropertyValuesQuery(
+ property_type=PropertyType.EVENT, property_key="$feature/beta", search_value=search_value
+ )
+ )
+ assert [r.name for r in results] == expected_names
+
+ @parameterized.expand(
+ [
+ (
+ "variants",
+ MULTIVARIATE_FILTERS,
+ variant_filters("redesign", "control"),
+ variant_filters("fresh", "control"),
+ ["control", "false", "fresh", "redesign", "test", "true"],
+ ),
+ (
+ "string_flag",
+ string_flag_filters("compact"),
+ string_flag_filters("wide", "dense"),
+ string_flag_filters("standard"),
+ ["compact", "dense", "false", "standard", "true", "wide"],
+ ),
+ (
+ "holdout",
+ {**MULTIVARIATE_FILTERS, "holdout": {"id": 42, "exclusion_percentage": 10}},
+ MULTIVARIATE_FILTERS,
+ MULTIVARIATE_FILTERS,
+ ["control", "false", "holdout-42", "test", "true"],
+ ),
+ ]
+ )
+ def test_feature_flag_property_values_keep_values_from_earlier_flags_with_the_key(
+ self, _name, first_filters, edited_filters, current_filters, expected_names
+ ):
+ earlier = FeatureFlag.objects.create(team=self.team, key="beta", created_by=self.user, filters=first_filters)
+ earlier.filters = edited_filters
+ earlier.save()
+ earlier.delete()
+ FeatureFlag.objects.create(team=self.team, key="beta", created_by=self.user, filters=current_filters)
+
+ results = self._run(PropertyValuesQuery(property_type=PropertyType.EVENT, property_key="$feature/beta"))
+ assert sorted(str(r.name) for r in results) == expected_names
+
+ def test_feature_flag_property_values_skip_history_of_flags_hidden_from_any_member(self):
+ self.organization.available_product_features = [
+ {"key": AvailableFeature.ACCESS_CONTROL, "name": AvailableFeature.ACCESS_CONTROL}
+ ]
+ self.organization.save()
+ hidden = FeatureFlag.objects.create(
+ team=self.team, key="beta", created_by=self.user, filters=MULTIVARIATE_FILTERS
+ )
+ hidden.filters = variant_filters("secret")
+ hidden.save()
+ hidden.key = "gamma"
+ hidden.save()
+ FeatureFlag.objects.create(team=self.team, key="beta", created_by=self.user, filters=variant_filters("fresh"))
+ query = PropertyValuesQuery(property_type=PropertyType.EVENT, property_key="$feature/beta")
+ self._run_cached(query)
+ create_access_control(
+ team_id=self.team.id, resource="feature_flag", access_level="none", resource_id=str(hidden.id)
+ )
+
+ assert [r.name for r in self._run_cached(query)] == ["fresh", "true", "false"]
+
+ def test_feature_flag_property_without_a_flag_in_the_project_uses_events_scan(self):
+ other_team = Team.objects.create(organization=Organization.objects.create(name="Other"))
+ FeatureFlag.objects.create(team=other_team, key="beta", filters=MULTIVARIATE_FILTERS)
+ _create_event(event="$pageview", distinct_id="u1", team=self.team, properties={"$feature/beta": "retired"})
+
+ results = self._run(PropertyValuesQuery(property_type=PropertyType.EVENT, property_key="$feature/beta"))
+ assert [r.name for r in results] == ["retired"]
+
+ @parameterized.expand(
+ [
+ ("rule_on_the_flag", "beta", ["retired"]),
+ ("rule_on_every_flag", None, ["retired"]),
+ ("rule_on_another_flag", "other", ["control", "test", "true", "false"]),
+ ]
+ )
+ def test_feature_flag_access_rule_added_after_caching_decides_the_source(
+ self, _name, restricted_key, expected_names
+ ):
+ self.organization.available_product_features = [
+ {"key": AvailableFeature.ACCESS_CONTROL, "name": AvailableFeature.ACCESS_CONTROL}
+ ]
+ self.organization.save()
+ flags = {
+ key: FeatureFlag.objects.create(team=self.team, key=key, created_by=self.user, filters=MULTIVARIATE_FILTERS)
+ for key in ("beta", "other")
+ }
+ _create_event(event="$pageview", distinct_id="u1", team=self.team, properties={"$feature/beta": "retired"})
+ flush_persons_and_events()
+ query = PropertyValuesQuery(property_type=PropertyType.EVENT, property_key="$feature/beta")
+ self._run_cached(query)
+ create_access_control(
+ team_id=self.team.id,
+ resource="feature_flag",
+ access_level="none",
+ resource_id=str(flags[restricted_key].id) if restricted_key else None,
+ )
+
+ assert [r.name for r in self._run_cached(query)] == expected_names
+
+ def test_restricted_feature_flag_property_is_not_served(self):
+ FeatureFlag.objects.create(team=self.team, key="beta", created_by=self.user, filters=MULTIVARIATE_FILTERS)
+
+ with patch(
+ "posthog.hogql_queries.property_values_query_runner.get_restricted_property_names",
+ return_value={"$feature/beta"},
+ ):
+ results = self._run(PropertyValuesQuery(property_type=PropertyType.EVENT, property_key="$feature/beta"))
+ assert results == []
+
@snapshot_clickhouse_queries
def test_person_property_values_basic(self):
_create_person(distinct_ids=["u1"], team=self.team, properties={"country": "US"})
@@ -441,10 +623,11 @@ class TestPropertyValuesQueryRunnerAggregatedTable(ClickhouseTestMixin, APIBaseT
)
assert {r.name for r in results} == {"$pageview"}
- def test_virtual_key_uses_events_scan(self):
+ @parameterized.expand([("virtual_key", "$virt_initial_channel_type"), ("feature_flag_key", "$feature/beta")])
+ def test_key_the_table_may_lack_uses_events_scan(self, _name, property_key):
runner = PropertyValuesQueryRunner(
team=self.team,
- query=PropertyValuesQuery(property_type=PropertyType.EVENT, property_key="$virt_initial_channel_type"),
+ query=PropertyValuesQuery(property_type=PropertyType.EVENT, property_key=property_key),
)
with self._flag_on():
assert runner._use_property_values_table is False
diff --git a/posthog/test/repo_invariants/feature_flag_raw_reads_baseline.txt b/posthog/test/repo_invariants/feature_flag_raw_reads_baseline.txt
index 971e8693ceee..1bb9e50ecf2a 100644
--- a/posthog/test/repo_invariants/feature_flag_raw_reads_baseline.txt
+++ b/posthog/test/repo_invariants/feature_flag_raw_reads_baseline.txt
@@ -39,9 +39,6 @@ products/feature_flags/backend/api/feature_flag.py::apply_encrypted_payload_resp
products/feature_flags/backend/api/feature_flag.py::find_dependent_flags::extra(sql on filters)
products/feature_flags/backend/api/feature_flag.py::find_dependent_flags_batch::dep_flag.filters.get('groups')
products/feature_flags/backend/api/feature_flag.py::find_dependent_flags_batch::extra(sql on filters)
-products/feature_flags/backend/api/flag_value.py::FlagValueViewSet.values::flag.filters.get('multivariate')
-products/feature_flags/backend/api/flag_value.py::FlagValueViewSet.values::flag.filters['multivariate']
-products/feature_flags/backend/api/flag_value.py::FlagValueViewSet.values::flag.filters['multivariate']
products/feature_flags/backend/api/organization_feature_flag.py::OrganizationFeatureFlagView._copy_feature_flag_to_target::source_flag.get_filters()
products/feature_flags/backend/api/organization_feature_flag.py::OrganizationFeatureFlagView._get_direct_flag_dependencies::flag.get_filters()
products/feature_flags/backend/api/organization_feature_flag.py::OrganizationFeatureFlagView._get_source_dependency_context::source_flag.get_filters()
diff --git a/products/feature_flags/backend/api/flag_value.py b/products/feature_flags/backend/api/flag_value.py
index f99102c617f2..7e184fe729e3 100644
--- a/products/feature_flags/backend/api/flag_value.py
+++ b/products/feature_flags/backend/api/flag_value.py
@@ -1,6 +1,3 @@
-from collections.abc import Mapping
-from typing import Any
-
from drf_spectacular.utils import OpenApiResponse
from rest_framework import request, response, serializers, viewsets
from rest_framework.decorators import action
@@ -9,7 +6,7 @@ from rest_framework.permissions import IsAuthenticated
from posthog.api.mixins import validated_request
from posthog.api.routing import TeamAndOrgViewSetMixin
-from products.feature_flags.backend.facade.config import detect_config_format, parse_v2_config
+from products.feature_flags.backend.facade.config import served_string_values
from products.feature_flags.backend.models.feature_flag import FeatureFlag
@@ -76,36 +73,6 @@ class FlagValueViewSet(TeamAndOrgViewSetMixin, viewsets.ViewSet):
self.check_object_permissions(request, flag)
# Always include true and false for any flag; a flag dependency on true matches any enabled value
- values: list[dict[str, bool | str]] = [{"name": True}, {"name": False}]
-
- config_format = detect_config_format(flag.filters).kind
- if config_format == "v1":
- # Add variant keys if this is a multivariate flag
- if flag.filters.get("multivariate") and flag.filters["multivariate"].get("variants"):
- for variant in flag.filters["multivariate"]["variants"]:
- variant_key = variant.get("key")
- if variant_key:
- values.append({"name": variant_key})
- elif config_format == "v2":
- values.extend({"name": value} for value in _v2_string_values(flag.filters))
+ values = [{"name": value} for value in [True, False, *served_string_values(flag.filters)]]
return response.Response({"results": values, "refreshing": False})
-
-
-def _v2_string_values(filters: Mapping[str, Any]) -> list[str]:
- """The strings a v2 string flag serves as its value, in rule order and then the default.
-
- Other return types serve only true or false as the flag value, and an undecodable document
- lists nothing beyond those.
- """
- try:
- config = parse_v2_config(filters)
- except (KeyError, TypeError, ValueError, AttributeError):
- return []
- if config.return_type != "string":
- return []
- candidates = [
- *(value for rule in config.rules for value in (rule.value, *rule.variant_values)),
- config.default_value,
- ]
- return list(dict.fromkeys(value for value in candidates if isinstance(value, str)))
diff --git a/products/feature_flags/backend/facade/config.py b/products/feature_flags/backend/facade/config.py
index dfa0d6fda8a5..e393c62b9e15 100644
--- a/products/feature_flags/backend/facade/config.py
+++ b/products/feature_flags/backend/facade/config.py
@@ -174,3 +174,29 @@ def _rule_v2(rule: Mapping[str, Any]) -> RuleV2:
value=None if rule_type == "experiment" else rule["value"],
variant_values=tuple(variant["value"] for variant in rule["variants"]) if rule_type == "experiment" else (),
)
+
+
+def served_string_values(filters: object) -> list[str]:
+ config = decode_config(filters)
+ if isinstance(config, ConfigV1):
+ multivariate = config.filters.get("multivariate")
+ variants = multivariate.get("variants") if isinstance(multivariate, Mapping) else None
+ return [variant["key"] for variant in variants or [] if variant.get("key")]
+ if isinstance(config, ConfigV2) and config.return_type == "string":
+ candidates = [
+ *(value for rule in config.rules for value in (rule.value, *rule.variant_values)),
+ config.default_value,
+ ]
+ return list(dict.fromkeys(value for value in candidates if isinstance(value, str)))
+ return []
+
+
+def served_holdout_values(filters: object) -> list[str]:
+ config = decode_config(filters)
+ holdout = config.filters.get("holdout") if isinstance(config, ConfigV1) else None
+ holdout_id = holdout.get("id") if isinstance(holdout, Mapping) else None
+ return [] if holdout_id is None else [holdout_variant(holdout_id)]
+
+
+def holdout_variant(holdout_id: object) -> str:
+ return f"holdout-{holdout_id}"
diff --git a/products/feature_flags/backend/facade/edit_history.py b/products/feature_flags/backend/facade/edit_history.py
index a5f376a1bf7f..c6de8e3b6592 100644
--- a/products/feature_flags/backend/facade/edit_history.py
+++ b/products/feature_flags/backend/facade/edit_history.py
@@ -4,6 +4,7 @@ An edit keeps only the values that decide who gets which variant: the variant sp
flag-level aggregation, and the bucketing settings. Pass them to ``facade.edits`` to learn what the edit did.
"""
+from collections.abc import Collection
from datetime import datetime
from enum import StrEnum
from typing import Any
@@ -14,6 +15,7 @@ from django.db.models.fields.json import KT
from posthog.dataclasses import frozen
from posthog.models.activity_logging.activity_log import AGENT_TRIGGER_JOB_TYPE, ActivityLog
+from products.feature_flags.backend.facade.config import holdout_variant
from products.feature_flags.backend.facade.edits import BucketingSetting
from products.feature_flags.backend.facade.enums import SCHEDULED_CHANGE_JOB_TYPE
@@ -24,6 +26,12 @@ _SETTING_FIELDS = {
BucketingSetting.BUCKETING_IDENTIFIER: "bucketing_identifier",
BucketingSetting.EXPERIENCE_CONTINUITY: "ensure_experience_continuity",
}
+_SERVED_STRING_PATHS = (
+ "multivariate.variants[*].key",
+ "rules[*].value",
+ "rules[*].variants[*].value",
+ "default_value",
+)
_PROJECTED = (
"before_variants",
"after_variants",
@@ -135,6 +143,33 @@ def flag_edits_since(*, team_id: int, feature_flag_id: int, since: datetime, lim
)
+def served_strings_in_edits(*, team_id: int, flag_key: str, excluded_flag_ids: Collection[str]) -> list[str]:
+ columns = {
+ f"served_{index}": _changed(_FILTERS, f'*.{path} ? (@.type() == "string")', function="jsonb_path_query_array")
+ for index, path in enumerate(_SERVED_STRING_PATHS)
+ }
+ rows = (
+ ActivityLog.objects.filter(
+ team_id=team_id,
+ scope="FeatureFlag",
+ detail__contains={"name": flag_key, "changes": [{"field": _FILTERS}]},
+ )
+ .exclude(item_id__in=excluded_flag_ids)
+ .annotate(
+ holdout_ids=_changed(_FILTERS, '*.holdout.id ? (@.type() == "number")', function="jsonb_path_query_array"),
+ **columns,
+ )
+ .order_by()
+ .values_list("holdout_ids", *columns)
+ .distinct()
+ )
+ served: list[str] = []
+ for holdout_ids, *strings in rows:
+ served.extend(holdout_variant(holdout_id) for holdout_id in holdout_ids)
+ served.extend(value for values in strings for value in values)
+ return list(dict.fromkeys(value for value in served if value))
+
+
def _author(*, job_type: str | None, is_system: bool | None, user_id: int | None) -> FlagEditAuthor:
# Check the trigger before the user, because an agent and a scheduled change save the flag as a user.
if job_type == AGENT_TRIGGER_JOB_TYPE:
@@ -166,10 +201,10 @@ def _changes_any_field(*fields: str) -> Q:
return query
-def _changed(field: str, path: str) -> Func:
+def _changed(field: str, path: str, *, function: str = "jsonb_path_query_first") -> Func:
return Func(
F("detail"),
Value(f'$.changes[*] ? (@.field == "{field}").{path}'),
- function="jsonb_path_query_first",
+ function=function,
output_field=JSONField(),
)
diff --git a/products/feature_flags/backend/facade/property_values.py b/products/feature_flags/backend/facade/property_values.py
new file mode 100644
index 000000000000..0eb6a659b376
--- /dev/null
+++ b/products/feature_flags/backend/facade/property_values.py
@@ -0,0 +1,61 @@
+from typing import TYPE_CHECKING
+
+from products.access_control.backend.facade.api import (
+ every_member_has_resource_access,
+ object_ids_restricted_from_any_member,
+)
+from products.feature_flags.backend.facade.config import served_holdout_values, served_string_values
+from products.feature_flags.backend.facade.edit_history import served_strings_in_edits
+from products.feature_flags.backend.models.feature_flag import FeatureFlag
+
+if TYPE_CHECKING:
+ from posthog.models.team import Team
+
+
+def flag_property_values_revision(team: "Team", key: str) -> str | None:
+ visible = _visible_flag(team, key)
+ if visible is None:
+ return None
+ flag, hidden_flag_ids = visible
+ return f"{flag.id}:{flag.updated_at}:{','.join(sorted(hidden_flag_ids))}"
+
+
+def get_flag_property_values(team: "Team", key: str) -> list[bool | str] | None:
+ visible = _visible_flag(team, key)
+ if visible is None:
+ return None
+ flag, hidden_flag_ids = visible
+ strings = [
+ *served_string_values(flag.filters),
+ *served_holdout_values(flag.filters),
+ *served_strings_in_edits(team_id=flag.team_id, flag_key=key, excluded_flag_ids=hidden_flag_ids),
+ ]
+ values: list[bool | str] = [*strings, True, False]
+ return values
+
+
+def _visible_flag(team: "Team", key: str) -> tuple[FeatureFlag, set[str]] | None:
+ flag = _find_flag(team, key)
+ # Suggestions are cached per team, not per user, so a flag hidden from any member is never served.
+ if flag is None or not every_member_has_resource_access(
+ team_id=flag.team_id, resource="feature_flag", required_level="viewer"
+ ):
+ return None
+ hidden_flag_ids = object_ids_restricted_from_any_member(
+ team_id=flag.team_id, resource="feature_flag", required_level="viewer"
+ )
+ if str(flag.id) in hidden_flag_ids:
+ return None
+ return flag, hidden_flag_ids
+
+
+def _find_flag(team: "Team", key: str) -> FeatureFlag | None:
+ # `filters` stays deferred, so the cache revision never loads it and values load it once on a cache miss.
+ flags = FeatureFlag.objects_including_soft_deleted.filter(team__project_id=team.project_id).only(
+ "team_id", "key", "deleted", "updated_at"
+ )
+ flag = flags.filter(key=key).order_by("deleted").first()
+ if flag is not None:
+ return flag
+ tombstoned = flags.filter(deleted=True, key__startswith=f"{key}:deleted:")
+ return next((flag for flag in tombstoned if flag.key_without_tombstone() == key), None)
diff --git a/products/feature_flags/backend/test/test_facade_edit_history.py b/products/feature_flags/backend/test/test_facade_edit_history.py
index f41c1edc49e4..680fa7233804 100644
--- a/products/feature_flags/backend/test/test_facade_edit_history.py
+++ b/products/feature_flags/backend/test/test_facade_edit_history.py
@@ -7,9 +7,10 @@ from django.utils import timezone
from parameterized import parameterized
+from posthog.models import Organization, Team
from posthog.models.activity_logging.activity_log import ActivityLog
-from products.feature_flags.backend.facade.edit_history import FlagEditAuthor, flag_edits_since
+from products.feature_flags.backend.facade.edit_history import FlagEditAuthor, flag_edits_since, served_strings_in_edits
from products.feature_flags.backend.models.feature_flag import FeatureFlag
@@ -59,3 +60,29 @@ class TestFlagEditsSince(BaseTest):
assert edit.author == expected
assert edit.user_id == (self.user.id if has_user else None)
assert edit.was_impersonated == bool(was_impersonated)
+
+
+class TestServedStringsInEdits(BaseTest):
+ def test_reads_only_the_teams_edits(self) -> None:
+ other_team = Team.objects.create(organization=Organization.objects.create(name="Other"))
+ for team, variant in ((self.team, "mine"), (other_team, "theirs")):
+ ActivityLog.objects.create(
+ team_id=team.id,
+ scope="FeatureFlag",
+ item_id="1",
+ activity="updated",
+ detail={
+ "name": "beta",
+ "changes": [
+ {
+ "type": "FeatureFlag",
+ "action": "changed",
+ "field": "filters",
+ "before": None,
+ "after": {"multivariate": {"variants": [{"key": variant}]}},
+ }
+ ],
+ },
+ )
+
+ assert served_strings_in_edits(team_id=self.team.id, flag_key="beta", excluded_flag_ids=()) == ["mine"]