: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.
Python ab-testingai-analyticsanalyticscdpdata-warehouseexperimentsfeature-flagsjavascriptproduct-analyticspythonreactsession-replaysurveystypescriptweb-analytics
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.pyindex 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_PREFIXfrom posthog.hogql.parser import parse_expr, parse_selectfrom posthog.hogql.query import execute_hogql_query@@ -31,6 +32,10 @@ from posthog.models.event.new_events_schema import use_new_events_schemafrom posthog.utils import convert_property_value, flatten, get_instance_region, relative_date_parsefrom 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[PropertyValuesQueryResponsetimings=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[PropertyValuesQueryResponseteam_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_propertydef _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 Falseteam_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 payloaddef _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.pyindex 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 parameterizedfrom posthog.hogql.query import execute_hogql_queryfrom posthog.clickhouse.client import sync_execute+from posthog.constants import AvailableFeaturefrom 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_queriesdef 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 Falsediff --git a/posthog/test/repo_invariants/feature_flag_raw_reads_baseline.txt b/posthog/test/repo_invariants/feature_flag_raw_reads_baseline.txtindex 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_respproducts/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.pyindex 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 OpenApiResponsefrom rest_framework import request, response, serializers, viewsetsfrom rest_framework.decorators import action@@ -9,7 +6,7 @@ from rest_framework.permissions import IsAuthenticatedfrom posthog.api.mixins import validated_requestfrom 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_valuesfrom 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.pyindex 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.pyindex 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 spflag-level aggregation, and the bucketing settings. Pass them to ``facade.edits`` to learn what the edit did."""+from collections.abc import Collectionfrom datetime import datetimefrom enum import StrEnumfrom typing import Any@@ -14,6 +15,7 @@ from django.db.models.fields.json import KTfrom posthog.dataclasses import frozenfrom posthog.models.activity_logging.activity_log import AGENT_TRIGGER_JOB_TYPE, ActivityLog+from products.feature_flags.backend.facade.config import holdout_variantfrom products.feature_flags.backend.facade.edits import BucketingSettingfrom 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.pynew file mode 100644index 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.pyindex 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 timezonefrom parameterized import parameterized+from posthog.models import Organization, Teamfrom 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_editsfrom products.feature_flags.backend.models.feature_flag import FeatureFlag@@ -59,3 +60,29 @@ class TestFlagEditsSince(BaseTest):assert edit.author == expectedassert 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"]