: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
refactor(experiments): one shape for flag changes after launch (#119307)
Marcel Poelker5d23a9a2ca61
diff --git a/frontend/src/scenes/experiments/stories/ExperimentHealthDebugTab.stories.tsx b/frontend/src/scenes/experiments/stories/ExperimentHealthDebugTab.stories.tsxindex 85fbe4246d45..61a84f84a25b 100644--- a/frontend/src/scenes/experiments/stories/ExperimentHealthDebugTab.stories.tsx+++ b/frontend/src/scenes/experiments/stories/ExperimentHealthDebugTab.stories.tsx@@ -14,11 +14,6 @@ import type { ExperimentHealthInputsApi } from 'products/experiments/frontend/geimport { recalculationMocks, resultsByMetricType } from './recalculationMocks'-const SPLIT_BEFORE = [- { key: 'control', rollout_percentage: 50 },- { key: 'test-1', rollout_percentage: 25 },- { key: 'test-2', rollout_percentage: 25 },-]const SPLIT_AFTER = [{ key: 'control', rollout_percentage: 34 },{ key: 'test-1', rollout_percentage: 33 },@@ -64,19 +59,27 @@ const HEALTH_INPUTS: ExperimentHealthInputsApi = {{ number: 2, rollout_percentage: 100, property_count: 0, reachable: true, pinned_variant: null },],variants: SPLIT_AFTER,+ split_text: 'control 34%, test-1 33%, test-2 33%',},flag_history: {checked: true,not_checked_reason: null,launched_at: '2025-01-06T10:00:00Z',team_timezone: 'UTC',- split_changes: [- { changed_at: '2025-01-20T14:30:00Z', before: SPLIT_BEFORE, after: SPLIT_AFTER, counted: true },+ changes: [+ {+ kind: 'split',+ changed_at: '2025-01-20T14:30:00Z',+ changed: 'Split',+ before: 'control 50%, test-1 25%, test-2 25%',+ after: 'control 34%, test-1 33%, test-2 33%',+ counted: true,+ },],- bucketing_changes: [],exposed_before_first: true,- split_exposed_between: null,- bucketing_exposed_between: null,+ exposed_between: [+ { kind: 'split', question: 'Exposed between the first and last split change', exposed: null },+ ],},condition_set_traffic_status: 'read',condition_set_traffic: {diff --git a/products/experiments/backend/facade/contracts.py b/products/experiments/backend/facade/contracts.pyindex cafd2297156e..82160dc8d632 100644--- a/products/experiments/backend/facade/contracts.py+++ b/products/experiments/backend/facade/contracts.py@@ -136,6 +136,12 @@ class ExperimentHealthInputsTrafficStatus(LabeledStrEnum):UNKNOWN = "unknown"+class ExperimentHealthFlagChangeKind(LabeledStrEnum):+ SPLIT = "split"+ # A setting that decides the variant draw: the key, the group type, the bucketing identifier or persistence.+ BUCKETING = "bucketing"++class ExperimentHealthFindingSeverity(LabeledStrEnum):# The values are the severities of the platform's health issues (posthog/models/health_issue.py), so a# finding can become a health issue by value. The labels differ on purpose: two choice sets with the samediff --git a/products/experiments/backend/health/checks/bucketing_changed.py b/products/experiments/backend/health/checks/bucketing_changed.pyindex 6e1605ea36ba..ef13611c8b30 100644--- a/products/experiments/backend/health/checks/bucketing_changed.py+++ b/products/experiments/backend/health/checks/bucketing_changed.py@@ -6,13 +6,11 @@ I/O: `health/exposure_gate.py` loads the changes and the exposure answers.People exposed before such a change get a new draw, so they can get another variant after it."""-from datetime import UTC-from products.experiments.backend.facade.contracts import (ExperimentHealthFinding,- ExperimentHealthFindingActionKind,ExperimentHealthFindingCode,ExperimentHealthFindingSeverity,+ ExperimentHealthFlagChangeKind,)from products.experiments.backend.health.bucketing_changes import (BucketingChangeShape,@@ -20,21 +18,19 @@ from products.experiments.backend.health.bucketing_changes import (bucketing_net_effect,describe_bucketing_value,)-from products.experiments.backend.health.checks.change_wording import (- delay,- duration,- not_checked_because,- not_checked_next_step,- suggested_start,- the_change,+from products.experiments.backend.health.checks.change_wording import duration, suggested_start, the_change+from products.experiments.backend.health.checks.flag_change_findings import (+ change_finding,+ changes_not_checked,+ delay_after_launch,+ history_to_check,+ not_checked_finding,)-from products.experiments.backend.health.checks.split_changed import NOT_CHECKEDfrom products.experiments.backend.health.context import (BucketingChange,BucketingSetting,FlagHistory,FlagHistoryNotChecked,- FlagHistoryNotCheckedReason,HealthContext,)from products.experiments.backend.health.split_changes import format_change_time@@ -53,23 +49,19 @@ _SETTING_NAMES = {def bucketing_changed_mid_run(ctx: HealthContext) -> ExperimentHealthFinding | None:- history = ctx.flag_history- flag = ctx.flag- if history is None or flag is None or flag.deleted or not ctx.is_running or ctx.archived:- return None- # `flag_variants_mismatch` reports a flag without variants, and the variants have to come back first.- if not any(variant.key for variant in flag.variants):+ history = history_to_check(ctx)+ if history is None:return Noneif isinstance(history, FlagHistoryNotChecked):return _not_checked(history)- effect = bucketing_net_effect(history.counted_bucketing_changes)+ effect = bucketing_net_effect(history.counted(BucketingChange))if effect is None:return Noneif effect.shape == BucketingChangeShape.REVERTED:first_at = format_change_time(effect.first.changed_at, history.team_timezone)changed = _changed_settings(effect)- if history.bucketing_exposed_between is False:+ if history.exposed_between.get(ExperimentHealthFlagChangeKind.BUCKETING) is False:span = duration((effect.last.changed_at - effect.first.changed_at).total_seconds())return _finding(history,@@ -89,7 +81,7 @@ def bucketing_changed_mid_run(ctx: HealthContext) -> ExperimentHealthFinding | Ntitle=_TITLE,sentences=[f"{changed} changed on {first_at} and {_was(effect)} set back on {last_at}.",- *_delay(history, effect),+ *delay_after_launch(history, effect),"People exposed in between got a new variant draw, so they may have switched variants.",f"Move the start date to {suggested_start(effect.last.changed_at, history.team_timezone)}, or ""reset the experiment.",@@ -104,7 +96,7 @@ def bucketing_changed_mid_run(ctx: HealthContext) -> ExperimentHealthFinding | Ntitle=_KEY_TITLE if effect.shape == BucketingChangeShape.KEY_CHANGED else _TITLE,sentences=[*(_what_changed(net, history.team_timezone) for net in effect.net_changes),- *_delay(history, effect),+ *delay_after_launch(history, effect),*_consequence(effect),f"Reset the experiment, or move its start date to {start_at}.",],@@ -112,33 +104,21 @@ def bucketing_changed_mid_run(ctx: HealthContext) -> ExperimentHealthFinding | Ndef _not_checked(history: FlagHistoryNotChecked) -> ExperimentHealthFinding | None:- # `split_changed_mid_run` reports a history the reader can't view, for every kind of change.- if history.reason == FlagHistoryNotCheckedReason.NO_HISTORY_ACCESS:- return None- effect = bucketing_net_effect(history.bucketing_changes)+ effect = bucketing_net_effect(changes_not_checked(history, BucketingChange))if effect is None:return None- change = the_change(effect.change_count, "the")if effect.shape == BucketingChangeShape.REVERTED:at = format_change_time(effect.last.changed_at, history.team_timezone)what_changed = [f"{_changed_settings(effect)} changed after launch and {_was(effect)} set back on {at}."]else:what_changed = [_what_changed(net, history.team_timezone) for net in effect.net_changes]- return ExperimentHealthFinding(+ return not_checked_finding(+ history,+ effect,code=ExperimentHealthFindingCode.BUCKETING_CHANGED_MID_RUN,- subcode=NOT_CHECKED,- severity=ExperimentHealthFindingSeverity.INFO,title=_NOT_CHECKED_TITLE,- detail=" ".join(- [- *what_changed,- f"This check can't tell whether anyone was exposed before {change}, because "- f"{not_checked_because(history.reason)}.",- not_checked_next_step(history.reason, change),- ]- ),- evidence={"reason": history.reason.value, **_evidence(history, effect, exposed_before_change=None)},- actions=(ExperimentHealthFindingActionKind.OPEN_FEATURE_FLAG_HISTORY,),+ what_changed=what_changed,+ kind_evidence=_kind_evidence(effect),diagnostic_ref="A6",)@@ -197,15 +177,6 @@ def _was(effect: BucketingNetEffect) -> str:return "was" if len({_SETTING_NAMES[setting] for setting in effect.changed_settings}) == 1 else "were"-def _delay(history: FlagHistory, effect: BucketingNetEffect) -> list[str]:- return delay(- launched_at=history.launched_at,- first_changed_at=effect.first.changed_at,- exposed_before_first=history.exposed_before_first,- change_count=effect.change_count,- )--def _finding(history: FlagHistory,effect: BucketingNetEffect,@@ -214,26 +185,18 @@ def _finding(title: str,sentences: list[str],) -> ExperimentHealthFinding:- return ExperimentHealthFinding(+ return change_finding(+ history,+ effect,code=ExperimentHealthFindingCode.BUCKETING_CHANGED_MID_RUN,subcode=effect.shape.value,severity=severity,title=title,- detail=" ".join(sentences),- evidence=_evidence(history, effect, exposed_before_change=history.exposed_before_first),- actions=(ExperimentHealthFindingActionKind.OPEN_FEATURE_FLAG_HISTORY,),+ sentences=sentences,+ kind_evidence=_kind_evidence(effect),diagnostic_ref="A6",)-def _evidence(- history: FlagHistory | FlagHistoryNotChecked, effect: BucketingNetEffect, *, exposed_before_change: bool | None-) -> dict[str, str | int | bool | None]:- return {- "change_count": effect.change_count,- "first_changed_at": effect.first.changed_at.astimezone(UTC).isoformat(),- "last_changed_at": effect.last.changed_at.astimezone(UTC).isoformat(),- "changed_settings": ",".join(effect.changed_settings),- "exposed_before_change": exposed_before_change,- "seconds_after_launch": int((effect.first.changed_at - history.launched_at).total_seconds()),- }+def _kind_evidence(effect: BucketingNetEffect) -> dict[str, str]:+ return {"changed_settings": ",".join(effect.changed_settings)}diff --git a/products/experiments/backend/health/checks/flag_change_findings.py b/products/experiments/backend/health/checks/flag_change_findings.pynew file mode 100644index 000000000000..f4e60455655f--- /dev/null+++ b/products/experiments/backend/health/checks/flag_change_findings.py@@ -0,0 +1,181 @@+"""+What the findings about flag changes after launch share besides their words, and the finding for a flag history that+the reader can't view. Pure functions, no I/O: `health/exposure_gate.py` loads the changes and the exposure answers.+"""++from collections.abc import Mapping, Sequence+from datetime import UTC, datetime+from typing import Protocol++from products.experiments.backend.facade.contracts import (+ ExperimentHealthFinding,+ ExperimentHealthFindingActionKind,+ ExperimentHealthFindingCode,+ ExperimentHealthFindingSeverity,+)+from products.experiments.backend.health.checks.change_wording import (+ delay,+ not_checked_because,+ not_checked_next_step,+ the_change,+)+from products.experiments.backend.health.context import (+ FlagChange,+ FlagHistory,+ FlagHistoryNotChecked,+ FlagHistoryNotCheckedReason,+ HealthContext,+)++# pinned: the subcode of a flag history that was not checked against the exposures. The page sends it as+# `finding_variant` on the health finding events.+NOT_CHECKED = "not_checked"+++class _Change(Protocol):+ @property+ def changed_at(self) -> datetime: ...+++class ChangeEffect(Protocol):+ """The net effect of the changes of one kind, as each kind's module computes it."""++ @property+ def first(self) -> _Change: ...++ @property+ def last(self) -> _Change: ...++ @property+ def change_count(self) -> int: ...+++def history_to_check(ctx: HealthContext) -> FlagHistory | FlagHistoryNotChecked | None:+ """The flag history that the flag-change checks read, or None when they don't apply."""+ history = ctx.flag_history+ flag = ctx.flag+ if history is None or flag is None or flag.deleted or not ctx.is_running or ctx.archived:+ return None+ # `flag_variants_mismatch` reports a flag without variants, and the variants have to come back first.+ if not any(variant.key for variant in flag.variants):+ return None+ return history+++def flag_history_not_readable(ctx: HealthContext) -> ExperimentHealthFinding | None:+ """One finding for every kind of change when the reader can't view the flag's history."""+ history = history_to_check(ctx)+ if (+ not isinstance(history, FlagHistoryNotChecked)+ or history.reason != FlagHistoryNotCheckedReason.NO_HISTORY_ACCESS+ ):+ return None+ return ExperimentHealthFinding(+ # pinned: insights and the page read this code and subcode for this finding.+ code=ExperimentHealthFindingCode.SPLIT_CHANGED_MID_RUN,+ subcode=NOT_CHECKED,+ severity=ExperimentHealthFindingSeverity.INFO,+ title="The flag history was not checked",+ detail=(+ "This check can't see whether the flag's variant split, key or bucketing changed after launch, "+ f"because {not_checked_because(history.reason)}. Viewing the history needs viewer access to the "+ "flag and, with an API key, the activity_log:read scope."+ ),+ evidence={"reason": history.reason.value},+ # The flag history is the page this caller can't open.+ actions=(),+ diagnostic_ref="E3",+ )+++def changes_not_checked[C: FlagChange](history: FlagHistoryNotChecked, kind: type[C]) -> tuple[C, ...]:+ """The changes of one kind that a check reports as not checked. Empty for a history the reader can't view, which+ `flag_history_not_readable` reports."""+ if history.reason == FlagHistoryNotCheckedReason.NO_HISTORY_ACCESS:+ return ()+ return history.of_kind(kind)+++def change_finding(+ history: FlagHistory,+ effect: ChangeEffect,+ *,+ code: ExperimentHealthFindingCode,+ subcode: str,+ severity: ExperimentHealthFindingSeverity,+ title: str,+ sentences: Sequence[str],+ kind_evidence: Mapping[str, str | int | bool | None],+ diagnostic_ref: str,+) -> ExperimentHealthFinding:+ return ExperimentHealthFinding(+ code=code,+ subcode=subcode,+ severity=severity,+ title=title,+ detail=" ".join(sentences),+ evidence=change_evidence(+ history, effect, kind_evidence=kind_evidence, exposed_before_change=history.exposed_before_first+ ),+ actions=(ExperimentHealthFindingActionKind.OPEN_FEATURE_FLAG_HISTORY,),+ diagnostic_ref=diagnostic_ref,+ )+++def not_checked_finding(+ history: FlagHistoryNotChecked,+ effect: ChangeEffect,+ *,+ code: ExperimentHealthFindingCode,+ title: str,+ what_changed: Sequence[str],+ kind_evidence: Mapping[str, str | int | bool | None],+ diagnostic_ref: str,+) -> ExperimentHealthFinding:+ change = the_change(effect.change_count, "the")+ return ExperimentHealthFinding(+ code=code,+ subcode=NOT_CHECKED,+ severity=ExperimentHealthFindingSeverity.INFO,+ title=title,+ detail=" ".join(+ [+ *what_changed,+ f"This check can't tell whether anyone was exposed before {change}, because "+ f"{not_checked_because(history.reason)}.",+ not_checked_next_step(history.reason, change),+ ]+ ),+ evidence={+ "reason": history.reason.value,+ **change_evidence(history, effect, kind_evidence=kind_evidence, exposed_before_change=None),+ },+ actions=(ExperimentHealthFindingActionKind.OPEN_FEATURE_FLAG_HISTORY,),+ diagnostic_ref=diagnostic_ref,+ )+++def change_evidence(+ history: FlagHistory | FlagHistoryNotChecked,+ effect: ChangeEffect,+ *,+ kind_evidence: Mapping[str, str | int | bool | None],+ exposed_before_change: bool | None,+) -> dict[str, str | int | bool | None]:+ return {+ "change_count": effect.change_count,+ "first_changed_at": effect.first.changed_at.astimezone(UTC).isoformat(),+ "last_changed_at": effect.last.changed_at.astimezone(UTC).isoformat(),+ **kind_evidence,+ "exposed_before_change": exposed_before_change,+ "seconds_after_launch": int((effect.first.changed_at - history.launched_at).total_seconds()),+ }+++def delay_after_launch(history: FlagHistory, effect: ChangeEffect) -> list[str]:+ return delay(+ launched_at=history.launched_at,+ first_changed_at=effect.first.changed_at,+ exposed_before_first=history.exposed_before_first,+ change_count=effect.change_count,+ )diff --git a/products/experiments/backend/health/checks/flag_state.py b/products/experiments/backend/health/checks/flag_state.pyindex e9af1652e809..a01e8d87f3d1 100644--- a/products/experiments/backend/health/checks/flag_state.py+++ b/products/experiments/backend/health/checks/flag_state.py@@ -12,7 +12,7 @@ from products.experiments.backend.facade.contracts import (ExperimentHealthFindingCode,ExperimentHealthFindingSeverity,)-from products.experiments.backend.health.context import FlagHistoryNotChecked, FlagState, HealthContext+from products.experiments.backend.health.context import FlagHistoryNotChecked, FlagState, HealthContext, SplitChangefrom products.experiments.backend.health.split_changes import (SplitChangeShape,describe_split,@@ -149,7 +149,7 @@ def _rollout_since(ctx: HealthContext) -> str:if history is None:return ""effect = net_effect(- history.split_changes if isinstance(history, FlagHistoryNotChecked) else history.counted_split_changes+ history.of_kind(SplitChange) if isinstance(history, FlagHistoryNotChecked) else history.counted(SplitChange))if effect is None or effect.shape != SplitChangeShape.VARIANT_ROLLED_OUT:return ""diff --git a/products/experiments/backend/health/checks/split_changed.py b/products/experiments/backend/health/checks/split_changed.pyindex f81386f3f6b8..bba42f2ab64b 100644--- a/products/experiments/backend/health/checks/split_changed.py+++ b/products/experiments/backend/health/checks/split_changed.py@@ -5,30 +5,29 @@ functions, no I/O: `health/exposure_gate.py` loads the changes and the exposurePeople exposed before such a change can get another variant after it, so the results mix two assignments."""-from datetime import UTCfrom typing import Literalfrom products.experiments.backend.facade.contracts import (ExperimentHealthFinding,- ExperimentHealthFindingActionKind,ExperimentHealthFindingCode,ExperimentHealthFindingSeverity,+ ExperimentHealthFlagChangeKind,)-from products.experiments.backend.health.checks.change_wording import (- delay,- duration,- not_checked_because,- not_checked_next_step,- suggested_start,- the_change,+from products.experiments.backend.health.checks.change_wording import duration, suggested_start, the_change+from products.experiments.backend.health.checks.flag_change_findings import (+ change_finding,+ changes_not_checked,+ delay_after_launch,+ history_to_check,+ not_checked_finding,)from products.experiments.backend.health.checks.flag_state import is_single_variant_shippedfrom products.experiments.backend.health.context import (FlagHistory,FlagHistoryNotChecked,- FlagHistoryNotCheckedReason,FlagState,HealthContext,+ SplitChange,)from products.experiments.backend.health.split_changes import (SplitChangeShape,@@ -42,31 +41,26 @@ from products.experiments.backend.health.split_changes import (zeroed_variant_keys,)-# pinned: the subcode of a split history that was not checked against the exposures. The page sends it as-# `finding_variant` on the health finding events.-NOT_CHECKED = "not_checked"-_TITLE = "The variant split changed after launch"_REVERTED_INFO_TITLE = "The variant split changed and was set back"_NOT_CHECKED_TITLE = "Variant split changes were not checked"-_HISTORY_NOT_CHECKED_TITLE = "The flag history was not checked"def split_changed_mid_run(ctx: HealthContext) -> ExperimentHealthFinding | None:- history = ctx.flag_history+ history = history_to_check(ctx)flag = ctx.flag- if history is None or flag is None or flag.deleted or not ctx.is_running or ctx.archived:- return None- # `flag_variants_mismatch` reports a flag without variants, and the variants have to come back first.- if not any(variant.key for variant in flag.variants):+ if history is None or flag is None:return Noneif isinstance(history, FlagHistoryNotChecked):return _not_checked(history, flag)- effect = net_effect(history.counted_split_changes)+ effect = net_effect(history.counted(SplitChange))if effect is None or _reported_as_shipped(effect, flag):return None- if effect.shape == SplitChangeShape.REVERTED and history.split_exposed_between is False:+ if (+ effect.shape == SplitChangeShape.REVERTED+ and history.exposed_between.get(ExperimentHealthFlagChangeKind.SPLIT) is False+ ):return _finding(history,effect,@@ -83,7 +77,7 @@ def split_changed_mid_run(ctx: HealthContext) -> ExperimentHealthFinding | None:title=_TITLE,sentences=[*_reverted(history, effect),- *_delay(history, effect),+ *delay_after_launch(history, effect),"People exposed in between may have switched variants.",f"Move the start date to {start_at}, or reset the experiment.",],@@ -95,7 +89,7 @@ def split_changed_mid_run(ctx: HealthContext) -> ExperimentHealthFinding | None:title=_TITLE,sentences=[_what_changed(history, effect),- *_delay(history, effect),+ *delay_after_launch(history, effect),*_consequence(history, effect),"A sample ratio mismatch or users in more than one variant can come from "f"{the_change(effect.change_count, 'this')}.",@@ -104,27 +98,9 @@ def split_changed_mid_run(ctx: HealthContext) -> ExperimentHealthFinding | None:def _not_checked(history: FlagHistoryNotChecked, flag: FlagState) -> ExperimentHealthFinding | None:- # This finding speaks for the bucketing check too, because neither can read the history for this reason.- if history.reason == FlagHistoryNotCheckedReason.NO_HISTORY_ACCESS:- return ExperimentHealthFinding(- code=ExperimentHealthFindingCode.SPLIT_CHANGED_MID_RUN,- subcode=NOT_CHECKED,- severity=ExperimentHealthFindingSeverity.INFO,- title=_HISTORY_NOT_CHECKED_TITLE,- detail=(- "This check can't see whether the flag's variant split, key or bucketing changed after launch, "- f"because {not_checked_because(history.reason)}. Viewing the history needs viewer access to the "- "flag and, with an API key, the activity_log:read scope."- ),- evidence={"reason": history.reason.value},- # The flag history is the page this caller can't open.- actions=(),- diagnostic_ref="E3",- )- effect = net_effect(history.split_changes)+ effect = net_effect(changes_not_checked(history, SplitChange))if effect is None or _reported_as_shipped(effect, flag):return None- change = the_change(effect.change_count, "the")at = format_change_time(effect.last.changed_at, history.team_timezone)from_split = describe_split(effect.from_split)if effect.shape == SplitChangeShape.REVERTED:@@ -139,21 +115,13 @@ def _not_checked(history: FlagHistoryNotChecked, flag: FlagState) -> ExperimentH)else:what_changed = f"The variant split changed from {from_split} to {describe_split(effect.to_split)} on {at}."- return ExperimentHealthFinding(+ return not_checked_finding(+ history,+ effect,code=ExperimentHealthFindingCode.SPLIT_CHANGED_MID_RUN,- subcode=NOT_CHECKED,- severity=ExperimentHealthFindingSeverity.INFO,title=_NOT_CHECKED_TITLE,- detail=" ".join(- [- what_changed,- f"This check can't tell whether anyone was exposed before {change}, because "- f"{not_checked_because(history.reason)}.",- not_checked_next_step(history.reason, change),- ]- ),- evidence={"reason": history.reason.value, **_change_evidence(history, effect, exposed_before_change=None)},- actions=(ExperimentHealthFindingActionKind.OPEN_FEATURE_FLAG_HISTORY,),+ what_changed=[what_changed],+ kind_evidence=_kind_evidence(effect),diagnostic_ref="E3",)@@ -249,21 +217,12 @@ def _reverted(history: FlagHistory, effect: SplitNetEffect) -> list[str]:f"and was set back to {from_split}."]changed_to = describe_split(effect.first.after)- if history.split_exposed_between is False:+ if history.exposed_between.get(ExperimentHealthFlagChangeKind.SPLIT) is False:span = duration((effect.last.changed_at - effect.first.changed_at).total_seconds())return [f"The split was set to {changed_to} on {first_at} and set back {span} later."]return [f"The split was set to {changed_to} on {first_at} and set back to {from_split} on {last_at}."]-def _delay(history: FlagHistory, effect: SplitNetEffect) -> list[str]:- return delay(- launched_at=history.launched_at,- first_changed_at=effect.first.changed_at,- exposed_before_first=history.exposed_before_first,- change_count=effect.change_count,- )--def _finding(history: FlagHistory,effect: SplitNetEffect,@@ -272,32 +231,23 @@ def _finding(title: str,sentences: list[str],) -> ExperimentHealthFinding:- return ExperimentHealthFinding(+ return change_finding(+ history,+ effect,code=ExperimentHealthFindingCode.SPLIT_CHANGED_MID_RUN,subcode=effect.shape.value,severity=severity,title=title,- detail=" ".join(sentences),- evidence=_change_evidence(history, effect, exposed_before_change=history.exposed_before_first),- actions=(ExperimentHealthFindingActionKind.OPEN_FEATURE_FLAG_HISTORY,),+ sentences=sentences,+ kind_evidence=_kind_evidence(effect),diagnostic_ref=("E4" if effect.shape in (SplitChangeShape.VARIANT_ADDED, SplitChangeShape.VARIANT_REMOVED) else "E3"),)-def _change_evidence(- history: FlagHistory | FlagHistoryNotChecked, effect: SplitNetEffect, *, exposed_before_change: bool | None-) -> dict[str, str | int | bool | None]:- return {- "change_count": effect.change_count,- "first_changed_at": effect.first.changed_at.astimezone(UTC).isoformat(),- "last_changed_at": effect.last.changed_at.astimezone(UTC).isoformat(),- "from": describe_split(effect.from_split),- "to": describe_split(effect.to_split),- "exposed_before_change": exposed_before_change,- "seconds_after_launch": int((effect.first.changed_at - history.launched_at).total_seconds()),- }+def _kind_evidence(effect: SplitNetEffect) -> dict[str, str]:+ return {"from": describe_split(effect.from_split), "to": describe_split(effect.to_split)}def _rolled_out_variant(effect: SplitNetEffect, *, starts_sentence: bool) -> str:diff --git a/products/experiments/backend/health/context.py b/products/experiments/backend/health/context.pyindex 592d80c0e02c..ff10562b394b 100644--- a/products/experiments/backend/health/context.py+++ b/products/experiments/backend/health/context.py@@ -6,6 +6,7 @@ from posthog.schema import MultipleVariantHandlingfrom posthog.dataclasses import frozen+from products.experiments.backend.facade.contracts import ExperimentHealthFlagChangeKindfrom products.experiments.backend.metric_resolution import saved_metric_link_role, saved_metric_linksfrom products.experiments.backend.models.experiment import Experimentfrom products.feature_flags.backend.facade.filters import pinned_variant, reachable_conditions@@ -45,6 +46,16 @@ class BucketingChange:after: str | int | bool | None+# A change of the flag after launch that can move exposed people. A new kind needs its class here, an+# `ExperimentHealthFlagChangeKind`, its read and its set-back question in `exposure_gate.py`, its row in+# `inputs_payload.py`, and its check.+FlagChange = SplitChange | BucketingChange+++def changes_of_kind[C: FlagChange](changes: tuple[FlagChange, ...], kind: type[C]) -> tuple[C, ...]:+ return tuple(change for change in changes if isinstance(change, kind))++@frozenclass FlagHistory:"""The changes of the flag after launch that can have moved exposed people, and whether anyone was exposed@@ -52,29 +63,23 @@ class FlagHistory:launched_at: datetimeteam_timezone: str- split_changes: tuple[SplitChange, ...]- bucketing_changes: tuple[BucketingChange, ...]+ # Every change of every kind, in time order.+ changes: tuple[FlagChange, ...]# The time of the first change, of any kind, with an exposure before it or an unknown answer. Every change# from then on counts. None when nobody was exposed before any change.counted_since: datetime | None# None when unknown: the exposure query failed, or the request ran out of queries or time.exposed_before_first: bool | None- # Asked per kind only when its last counted change sets back what its first changed. None when not asked,- # or unknown.- split_exposed_between: bool | None- bucketing_exposed_between: bool | None+ # Whether anyone was exposed between the first and the last counted change of a kind. Asked only when the last+ # sets back what the first changed, so a kind that was not asked is absent. None when unknown.+ exposed_between: Mapping[ExperimentHealthFlagChangeKind, bool | None]- @property- def counted_split_changes(self) -> tuple[SplitChange, ...]:- return _counted(self.split_changes, self.counted_since)+ def of_kind[C: FlagChange](self, kind: type[C]) -> tuple[C, ...]:+ return changes_of_kind(self.changes, kind)- @property- def counted_bucketing_changes(self) -> tuple[BucketingChange, ...]:- return _counted(self.bucketing_changes, self.counted_since)---def _counted[C: (SplitChange, BucketingChange)](changes: tuple[C, ...], since: datetime | None) -> tuple[C, ...]:- return () if since is None else tuple(change for change in changes if change.changed_at >= since)+ def counted[C: FlagChange](self, kind: type[C]) -> tuple[C, ...]:+ since = self.counted_since+ return () if since is None else tuple(change for change in self.of_kind(kind) if change.changed_at >= since)class FlagHistoryNotCheckedReason(StrEnum):@@ -93,9 +98,11 @@ class FlagHistoryNotChecked:reason: FlagHistoryNotCheckedReasonlaunched_at: datetimeteam_timezone: str- # Every change since launch. Empty for NO_HISTORY_ACCESS, which does not read them.- split_changes: tuple[SplitChange, ...]- bucketing_changes: tuple[BucketingChange, ...]+ # Every change since launch, in time order. Empty for NO_HISTORY_ACCESS, which does not read them.+ changes: tuple[FlagChange, ...]++ def of_kind[C: FlagChange](self, kind: type[C]) -> tuple[C, ...]:+ return changes_of_kind(self.changes, kind)@frozendiff --git a/products/experiments/backend/health/exposure_gate.py b/products/experiments/backend/health/exposure_gate.pyindex f8ee025a0c3a..97b3a2960387 100644--- a/products/experiments/backend/health/exposure_gate.py+++ b/products/experiments/backend/health/exposure_gate.py@@ -44,7 +44,7 @@ from posthog.exceptions import (from posthog.exceptions_capture import capture_exceptionfrom posthog.models.activity_logging.activity_log import ActivityLog-from products.experiments.backend.facade.contracts import ExperimentHealthReaderAccess+from products.experiments.backend.facade.contracts import ExperimentHealthFlagChangeKind, ExperimentHealthReaderAccessfrom products.experiments.backend.health.bucketing_changes import (BucketingChangeShape,bucketing_changes_from_activity,@@ -55,11 +55,13 @@ from products.experiments.backend.health.bucketing_changes import (from products.experiments.backend.health.context import (BucketingChange,BucketingSetting,+ FlagChange,FlagHistory,FlagHistoryNotChecked,FlagHistoryNotCheckedReason,Split,SplitChange,+ changes_of_kind,parse_variants,)from products.experiments.backend.health.split_changes import (@@ -278,16 +280,16 @@ def _load_flag_history(reason=FlagHistoryNotCheckedReason.NO_HISTORY_ACCESS,launched_at=launched_at,team_timezone=team_timezone,- split_changes=(),- bucketing_changes=(),+ changes=(),)- changes = _flag_changes_since(team_id=experiment.team_id, feature_flag_id=feature_flag_id, since=launched_at)+ read = _flag_changes_since(team_id=experiment.team_id, feature_flag_id=feature_flag_id, since=launched_at)flag = experiment.feature_flagtrust_flag_aggregation = conditions_follow_flag_aggregation(flag.aggregation_group_type_index, flag.conditions)+ bucketing = changes_of_kind(read, BucketingChange)relies_on_flag_aggregation = any(change.setting in (BucketingSetting.BUCKETING_IDENTIFIER, BucketingSetting.EXPERIENCE_CONTINUITY)- for change in changes.bucketing+ for change in bucketing)if relies_on_flag_aggregation and not trust_flag_aggregation:# The check then counts every identifier change, so it can report one that moved nobody.@@ -295,36 +297,33 @@ def _load_flag_history(_ConditionAggregationMismatch(), {"team_id": experiment.team_id, "feature_flag_id": feature_flag_id})# A change the flag service does not read moved nobody, so it neither counts nor needs an exposure window.- changes = replace(- changes,- bucketing=changes_that_apply(- changes.bucketing,- feature_flag_id=feature_flag_id,- aggregation=flag.aggregation_group_type_index,- bucketing_identifier=flag.bucketing_identifier,- trust_flag_aggregation=trust_flag_aggregation,- ),+ applied = changes_that_apply(+ bucketing,+ feature_flag_id=feature_flag_id,+ aggregation=flag.aggregation_group_type_index,+ bucketing_identifier=flag.bucketing_identifier,+ trust_flag_aggregation=trust_flag_aggregation,)+ # An applied bucketing change can move to a later save, so the changes are sorted again. The sort is stable,+ # so the changes of one kind keep their order.+ merged: list[FlagChange] = [change for change in read if not isinstance(change, BucketingChange)]+ merged.extend(applied)+ changes = tuple(sorted(merged, key=lambda change: change.changed_at))history = FlagHistory(launched_at=launched_at,team_timezone=team_timezone,- split_changes=changes.split,- bucketing_changes=changes.bucketing,+ changes=changes,counted_since=None,exposed_before_first=False,- split_exposed_between=None,- bucketing_exposed_between=None,+ exposed_between={},)- if not changes.times:+ times = _change_times(changes)+ if not times:return historyreason = _not_checked_reason(experiment, reader_access)if reason is not None:return FlagHistoryNotChecked(- reason=reason,- launched_at=launched_at,- team_timezone=team_timezone,- split_changes=changes.split,- bucketing_changes=changes.bucketing,+ reason=reason, launched_at=launched_at, team_timezone=team_timezone, changes=changes)timeline = _Timeline(@@ -332,8 +331,8 @@ def _load_flag_history(current_key=experiment.get_feature_flag_key(),current_split=parse_variants(experiment.feature_flag.variants),)- starts = (launched_at, *changes.times[:-1])- walk = [timeline.window(start=start, end=end) for start, end in zip(starts, changes.times)]+ starts = (launched_at, *times[:-1])+ walk = [timeline.window(start=start, end=end) for start, end in zip(starts, times)]gate = _ExposureGate(experiment, launched_at, prefetch=walk)for window in walk:exposed_before = gate.exposed(window)@@ -342,22 +341,7 @@ def _load_flag_history(breakif history.counted_since is None:return history-- split = history.counted_split_changes- bucketing = bucketing_net_effect(history.counted_bucketing_changes)- return replace(- history,- split_exposed_between=(- _exposed_between(gate, timeline, start=split[0].changed_at, end=split[-1].changed_at)- if split and same_assignment(split[0].before, split[-1].after)- else None- ),- bucketing_exposed_between=(- _exposed_between(gate, timeline, start=bucketing.first.changed_at, end=bucketing.last.changed_at)- if bucketing and bucketing.shape == BucketingChangeShape.REVERTED- else None- ),- )+ return replace(history, exposed_between=_exposed_between_set_backs(gate, timeline, history))def _not_checked_reason(@@ -378,28 +362,23 @@ def _not_checked_reason(return None-@frozen-class _FlagChanges:- split: tuple[SplitChange, ...]- bucketing: tuple[BucketingChange, ...]-- @property- def times(self) -> tuple[datetime, ...]:- # One save can change several things, so it is one point in time.- return tuple(- sorted({change.changed_at for change in self.split} | {change.changed_at for change in self.bucketing})- )+def _change_times(changes: tuple[FlagChange, ...]) -> tuple[datetime, ...]:+ # One save can change several things, so it is one point in time.+ return tuple(sorted({change.changed_at for change in changes}))class _Timeline:"""The flag's key and split at any time since launch, from its changes and its current state."""- def __init__(self, changes: _FlagChanges, *, current_key: str, current_split: Split) -> None:- self._changes = changes- self._key_changes = [change for change in changes.bucketing if change.setting == BucketingSetting.KEY]+ def __init__(self, changes: tuple[FlagChange, ...], *, current_key: str, current_split: Split) -> None:+ self._times = _change_times(changes)+ self._split_changes = changes_of_kind(changes, SplitChange)+ self._key_changes = [+ change for change in changes_of_kind(changes, BucketingChange) if change.setting == BucketingSetting.KEY+ ]# The changes come in time order, so a binary search finds the first change at or after a time.self._key_times = [change.changed_at for change in self._key_changes]- self._split_times = [change.changed_at for change in changes.split]+ self._split_times = [change.changed_at for change in self._split_changes]self._current_key = current_keyself._current_split = current_split@@ -419,10 +398,10 @@ class _Timeline:def split_before(self, at: datetime) -> Split:index = bisect_left(self._split_times, at)- return self._changes.split[index].before if index < len(self._changes.split) else self._current_split+ return self._split_changes[index].before if index < len(self._split_changes) else self._current_splitdef points_within(self, *, start: datetime, end: datetime) -> list[datetime]:- return [at for at in self._changes.times if start < at <= end]+ return [at for at in self._times if start < at <= end]def _exposed_between(gate: _ExposureGate, timeline: _Timeline, *, start: datetime, end: datetime) -> bool | None:@@ -445,6 +424,25 @@ def _exposed_between(gate: _ExposureGate, timeline: _Timeline, *, start: datetimreturn None if None in answers else False+def _exposed_between_set_backs(+ gate: _ExposureGate, timeline: _Timeline, history: FlagHistory+) -> dict[ExperimentHealthFlagChangeKind, bool | None]:+ """Asks, per kind, whether anyone was exposed between the first and the last counted change, when the last sets+ back what the first changed."""+ exposed_between: dict[ExperimentHealthFlagChangeKind, bool | None] = {}+ split = history.counted(SplitChange)+ if split and same_assignment(split[0].before, split[-1].after):+ exposed_between[ExperimentHealthFlagChangeKind.SPLIT] = _exposed_between(+ gate, timeline, start=split[0].changed_at, end=split[-1].changed_at+ )+ bucketing = bucketing_net_effect(history.counted(BucketingChange))+ if bucketing and bucketing.shape == BucketingChangeShape.REVERTED:+ exposed_between[ExperimentHealthFlagChangeKind.BUCKETING] = _exposed_between(+ gate, timeline, start=bucketing.first.changed_at, end=bucketing.last.changed_at+ )+ return exposed_between++_PROJECTED = ("before_variants","after_variants",@@ -454,7 +452,7 @@ _PROJECTED = ()-def _flag_changes_since(*, team_id: int, feature_flag_id: int, since: datetime) -> _FlagChanges:+def _flag_changes_since(*, team_id: int, feature_flag_id: int, since: datetime) -> tuple[FlagChange, ...]:rows = (ActivityLog.objects.filter(_changes_any_field(_FILTERS, *_SETTING_FIELDS.values()),@@ -476,8 +474,7 @@ def _flag_changes_since(*, team_id: int, feature_flag_id: int, since: datetime)).values("created_at", "job_type", *_PROJECTED))- split: list[SplitChange] = []- bucketing: list[BucketingChange] = []+ changes: list[FlagChange] = []for row in rows:changed_at = row["created_at"]split_change = split_change_from_activity(@@ -487,8 +484,8 @@ def _flag_changes_since(*, team_id: int, feature_flag_id: int, since: datetime)after_variants=row["after_variants"],)if split_change is not None:- split.append(split_change)- bucketing.extend(+ changes.append(split_change)+ changes.extend(bucketing_changes_from_activity(changed_at=changed_at,feature_flag_id=feature_flag_id,@@ -496,7 +493,7 @@ def _flag_changes_since(*, team_id: int, feature_flag_id: int, since: datetime)after=_settings(row, "after"),))- return _FlagChanges(split=tuple(split), bucketing=tuple(bucketing))+ return tuple(changes)def _settings(row: dict[str, object], side: str) -> dict[BucketingSetting, object]:diff --git a/products/experiments/backend/health/inputs_payload.py b/products/experiments/backend/health/inputs_payload.pyindex b939a8d84470..f534beabf8be 100644--- a/products/experiments/backend/health/inputs_payload.py+++ b/products/experiments/backend/health/inputs_payload.py@@ -3,15 +3,22 @@ from dataclasses import asdictfrom datetime import datetimefrom typing import Any-from products.experiments.backend.facade.contracts import ExperimentHealthInputsTrafficStatus+from products.experiments.backend.facade.contracts import (+ ExperimentHealthFlagChangeKind,+ ExperimentHealthInputsTrafficStatus,+)from products.experiments.backend.health.checks.forced_variant import needs_condition_set_trafficfrom products.experiments.backend.health.condition_set_traffic import denied_scanned_propertiesfrom products.experiments.backend.health.context import (+ BucketingChange,+ BucketingSetting,ConditionSetTraffic,+ FlagChange,FlagHistory,FlagHistoryNotChecked,FlagState,Split,+ SplitChange,)from products.experiments.backend.health.exposure_inputs import ExposureInputsfrom products.experiments.backend.health.loader import HealthInputs@@ -21,6 +28,22 @@ def _health_inputs_split(split: Split) -> list[dict[str, Any]]:return [{"key": variant.key, "rollout_percentage": variant.rollout_percentage} for variant in split]+def _health_inputs_percentage(value: float | None) -> str:+ # Written as the page writes a number, so 50.0 reads "50%".+ if value is None:+ return "unset"+ return f"{int(value) if value.is_integer() else value}%"+++def _health_inputs_split_text(split: Split) -> str:+ if not split:+ return "none"+ return ", ".join(+ f"{variant.key if variant.key is not None else 'no key'} {_health_inputs_percentage(variant.rollout_percentage)}"+ for variant in split+ )++def _health_inputs_flag(flag: FlagState) -> dict[str, Any]:reachable = {condition.number: condition for condition in flag.reachable_conditions}return {@@ -37,13 +60,41 @@ def _health_inputs_flag(flag: FlagState) -> dict[str, Any]:for number, group in enumerate(flag.release_groups, start=1)],"variants": _health_inputs_split(flag.variants),+ "split_text": _health_inputs_split_text(flag.variants),}-def _health_inputs_bucketing_value(value: str | int | bool | None) -> str | None:- if value is None or isinstance(value, str):- return value- return json.dumps(value)+_SETTING_LABELS = {+ BucketingSetting.KEY: "Key",+ BucketingSetting.AGGREGATION: "Match by group type",+ BucketingSetting.BUCKETING_IDENTIFIER: "Bucketing identifier",+ BucketingSetting.EXPERIENCE_CONTINUITY: "Persist across authentication",+}+++def _health_inputs_bucketing_value(value: str | int | bool | None) -> str:+ if value is None:+ return "none"+ return value if isinstance(value, str) else json.dumps(value)+++def _health_inputs_flag_change(change: FlagChange) -> dict[str, Any]:+ """A change as the staff view lists it, with its values as text, so the view needs no code per kind."""+ match change:+ case SplitChange():+ return {+ "kind": ExperimentHealthFlagChangeKind.SPLIT,+ "changed": "Split",+ "before": _health_inputs_split_text(change.before),+ "after": _health_inputs_split_text(change.after),+ }+ case BucketingChange():+ return {+ "kind": ExperimentHealthFlagChangeKind.BUCKETING,+ "changed": _SETTING_LABELS[change.setting],+ "before": _health_inputs_bucketing_value(change.before),+ "after": _health_inputs_bucketing_value(change.after),+ }def _health_inputs_flag_history(history: FlagHistory | FlagHistoryNotChecked) -> dict[str, Any]:@@ -51,43 +102,35 @@ def _health_inputs_flag_history(history: FlagHistory | FlagHistoryNotChecked) ->counted_since: datetime | None = history.counted_sincereason = Noneexposed_before_first = history.exposed_before_first- exposed_between = {- "split_exposed_between": history.split_exposed_between,- "bucketing_exposed_between": history.bucketing_exposed_between,- }+ exposed_between = history.exposed_betweenelse:- counted_since, reason, exposed_before_first = None, history.reason.value, None- exposed_between = dict.fromkeys(("split_exposed_between", "bucketing_exposed_between"))-- def counted(changed_at: datetime) -> bool:- return counted_since is not None and changed_at >= counted_since+ counted_since, reason, exposed_before_first, exposed_between = None, history.reason.value, None, {}+ changes = [+ {+ **_health_inputs_flag_change(change),+ "changed_at": change.changed_at,+ "counted": counted_since is not None and change.changed_at >= counted_since,+ }+ for change in history.changes+ ]+ counted_kinds = {change["kind"] for change in changes if change["counted"]}return {"checked": reason is None,"not_checked_reason": reason,"launched_at": history.launched_at,"team_timezone": history.team_timezone,- "split_changes": [- {- "changed_at": change.changed_at,- "before": _health_inputs_split(change.before),- "after": _health_inputs_split(change.after),- "counted": counted(change.changed_at),- }- for change in history.split_changes- ],- "bucketing_changes": [+ "changes": changes,+ "exposed_before_first": exposed_before_first,+ "exposed_between": [{- "changed_at": change.changed_at,- "setting": change.setting.value,- "before": _health_inputs_bucketing_value(change.before),- "after": _health_inputs_bucketing_value(change.after),- "counted": counted(change.changed_at),+ "kind": kind,+ "question": f"Exposed between the first and last {kind.label.lower()} change",+ "exposed": exposed_between.get(kind),}- for change in history.bucketing_changes+ for kind in ExperimentHealthFlagChangeKind+ if kind in counted_kinds],- "exposed_before_first": exposed_before_first,- **exposed_between,}diff --git a/products/experiments/backend/health/registry.py b/products/experiments/backend/health/registry.pyindex 4ad7ac77128c..d677c8ced8c3 100644--- a/products/experiments/backend/health/registry.py+++ b/products/experiments/backend/health/registry.py@@ -5,6 +5,7 @@ from posthog.exceptions_capture import capture_exceptionfrom products.experiments.backend.facade.contracts import ExperimentHealthFindingfrom products.experiments.backend.health.checks.bias_risk import bias_risk_multiple_excludedfrom products.experiments.backend.health.checks.bucketing_changed import bucketing_changed_mid_run+from products.experiments.backend.health.checks.flag_change_findings import flag_history_not_readablefrom products.experiments.backend.health.checks.flag_state import flag_statefrom products.experiments.backend.health.checks.flag_variants import flag_variants_mismatchfrom products.experiments.backend.health.checks.forced_variant import forced_variant_release_condition@@ -18,6 +19,7 @@ HealthCheck = Callable[[HealthContext], ExperimentHealthFinding | None]EXPERIMENT_HEALTH_CHECKS: tuple[HealthCheck, ...] = (flag_state,+ flag_history_not_readable,split_changed_mid_run,bucketing_changed_mid_run,flag_variants_mismatch,diff --git a/products/experiments/backend/health/test/factories.py b/products/experiments/backend/health/test/factories.pynew file mode 100644index 000000000000..ff6d76b453a8--- /dev/null+++ b/products/experiments/backend/health/test/factories.py@@ -0,0 +1,63 @@+from collections.abc import Mapping, Sequence+from datetime import datetime+from typing import TypedDict++from products.experiments.backend.facade.contracts import ExperimentHealthFlagChangeKind+from products.experiments.backend.health.context import (+ FlagChange,+ FlagHistory,+ FlagHistoryNotChecked,+ FlagHistoryNotCheckedReason,+ HealthContext,+)++# Tests set what their check reads with `dataclasses.replace`, so a new field of the context changes only this file.+RUNNING_CONTEXT = HealthContext(+ is_launched=True,+ is_running=True,+ has_ended=False,+ is_paused=False,+ archived=False,+ flag=None,+ baseline_variant_key=None,+ primary_metric_count=1,+ secondary_metric_count=0,+ exposures=None,+ flag_history=None,+ condition_set_traffic=None,+ excluded_variant_keys=frozenset(),+)+++class Status(TypedDict):+ is_launched: bool+ is_running: bool+ has_ended: bool+++RUNNING: Status = {"is_launched": True, "is_running": True, "has_ended": False}+ENDED: Status = {"is_launched": True, "is_running": False, "has_ended": True}+DRAFT: Status = {"is_launched": False, "is_running": False, "has_ended": False}+++def flag_history(+ changes: Sequence[FlagChange],+ *,+ launched_at: datetime,+ exposed_before_first: bool | None = True,+ exposed_between: Mapping[ExperimentHealthFlagChangeKind, bool | None] | None = None,+ not_checked: FlagHistoryNotCheckedReason | None = None,+) -> FlagHistory | FlagHistoryNotChecked:+ # Every change counts from the first, as when someone was exposed before it.+ if not_checked is not None:+ return FlagHistoryNotChecked(+ reason=not_checked, launched_at=launched_at, team_timezone="Europe/Berlin", changes=tuple(changes)+ )+ return FlagHistory(+ launched_at=launched_at,+ team_timezone="Europe/Berlin",+ changes=tuple(changes),+ counted_since=changes[0].changed_at if changes else None,+ exposed_before_first=exposed_before_first,+ exposed_between=exposed_between or {},+ )diff --git a/products/experiments/backend/health/test/test_bucketing_changed.py b/products/experiments/backend/health/test/test_bucketing_changed.pyindex 4333bc170abb..4e693184d767 100644--- a/products/experiments/backend/health/test/test_bucketing_changed.py+++ b/products/experiments/backend/health/test/test_bucketing_changed.py@@ -1,3 +1,4 @@+from dataclasses import replacefrom datetime import UTC, datetime, timedeltafrom typing import Any@@ -9,17 +10,17 @@ from products.experiments.backend.facade.contracts import (ExperimentHealthFindingActionKind,ExperimentHealthFindingCode,ExperimentHealthFindingSeverity,+ ExperimentHealthFlagChangeKind,)from products.experiments.backend.health.checks.bucketing_changed import bucketing_changed_mid_runfrom products.experiments.backend.health.context import (BucketingChange,BucketingSetting,- FlagHistory,- FlagHistoryNotChecked,FlagHistoryNotCheckedReason,HealthContext,parse_flag_state,)+from products.experiments.backend.health.test.factories import RUNNING_CONTEXT, flag_historyLAUNCHED_AT = datetime(2026, 9, 12, 10, 0, tzinfo=UTC)FIRST_CHANGE_AT = datetime(2026, 9, 12, 13, 4, tzinfo=UTC)@@ -44,45 +45,26 @@ def _context(variants: list[dict[str, Any]] = EVEN,not_checked: FlagHistoryNotCheckedReason | None = None,) -> HealthContext:- bucketing = tuple(+ bucketing = [BucketingChange(changed_at=first_change_at + timedelta(minutes=17 * index), setting=setting, before=before, after=after)for index, (setting, before, after) in enumerate(changes)- )- return HealthContext(- is_launched=True,+ ]+ return replace(+ RUNNING_CONTEXT,is_running=is_running,has_ended=not is_running,- is_paused=False,- archived=False,flag=parse_flag_state(active=True, deleted=False, groups=[{"properties": [], "rollout_percentage": 100}], variants=variants),- baseline_variant_key=None,- primary_metric_count=1,- secondary_metric_count=0,- exposures=None,- flag_history=FlagHistory(+ flag_history=flag_history(+ bucketing,launched_at=LAUNCHED_AT,- team_timezone="Europe/Berlin",- split_changes=(),- bucketing_changes=bucketing,- counted_since=bucketing[0].changed_at if bucketing else None,exposed_before_first=exposed_before_first,- split_exposed_between=None,- bucketing_exposed_between=exposed_between,- )- if not_checked is None- else FlagHistoryNotChecked(- reason=not_checked,- launched_at=LAUNCHED_AT,- team_timezone="Europe/Berlin",- split_changes=(),- bucketing_changes=bucketing,+ exposed_between={ExperimentHealthFlagChangeKind.BUCKETING: exposed_between},+ not_checked=not_checked,),- condition_set_traffic=None,- excluded_variant_keys=frozenset(),)diff --git a/products/experiments/backend/health/test/test_exposure_gate.py b/products/experiments/backend/health/test/test_exposure_gate.pyindex aba26727fd68..037e9612448d 100644--- a/products/experiments/backend/health/test/test_exposure_gate.py+++ b/products/experiments/backend/health/test/test_exposure_gate.py@@ -16,12 +16,14 @@ from posthog.models.activity_logging.activity_log import ActivityLogfrom posthog.models.team.team import Teamfrom posthog.models.user import User-from products.experiments.backend.facade.contracts import ExperimentHealthReaderAccess+from products.experiments.backend.facade.contracts import ExperimentHealthFlagChangeKind, ExperimentHealthReaderAccessfrom products.experiments.backend.health.context import (+ BucketingChange,BucketingSetting,FlagHistory,FlagHistoryNotChecked,FlagHistoryNotCheckedReason,+ SplitChange,)from products.experiments.backend.health.exposure_gate import (MAX_EXPOSURE_QUERIES,@@ -134,7 +136,7 @@ class TestLoadFlagHistory(BaseTest):history, query = self._load([False, True])assert isinstance(history, FlagHistory)- self.assertEqual([change.changed_at for change in history.counted_split_changes], changed_at[1:])+ self.assertEqual([change.changed_at for change in history.counted(SplitChange)], changed_at[1:])self.assertIs(history.exposed_before_first, True)self.assertEqual([(call.kwargs["window_start"], call.kwargs["window_end"]) for call in query.call_args_list],@@ -157,10 +159,10 @@ class TestLoadFlagHistory(BaseTest):history, query = self._load([False, True])assert isinstance(history, FlagHistory)- self.assertEqual([change.changed_at for change in history.split_changes], [changed_at[0], changed_at[2]])- self.assertEqual([change.changed_at for change in history.counted_split_changes], changed_at[2:])+ self.assertEqual([change.changed_at for change in history.of_kind(SplitChange)], [changed_at[0], changed_at[2]])+ self.assertEqual([change.changed_at for change in history.counted(SplitChange)], changed_at[2:])self.assertEqual(- [(change.changed_at, change.setting) for change in history.counted_bucketing_changes],+ [(change.changed_at, change.setting) for change in history.counted(BucketingChange)],[(changed_at[1], BucketingSetting.BUCKETING_IDENTIFIER),(changed_at[2], BucketingSetting.AGGREGATION),@@ -178,7 +180,7 @@ class TestLoadFlagHistory(BaseTest):assert isinstance(history, FlagHistory)self.assertEqual([call.kwargs["flag_key"] for call in query.call_args_list], ["first-key", "second-key"])- self.assertEqual([change.changed_at for change in history.counted_bucketing_changes], changed_at[1:])+ self.assertEqual([change.changed_at for change in history.counted(BucketingChange)], changed_at[1:])def test_a_key_set_back_asks_between_with_the_key_in_between(self) -> None:first_at = self.launched_at + timedelta(days=1)@@ -189,7 +191,7 @@ class TestLoadFlagHistory(BaseTest):history, query = self._load([True, False])assert isinstance(history, FlagHistory)- self.assertIs(history.bucketing_exposed_between, False)+ self.assertIs(history.exposed_between.get(ExperimentHealthFlagChangeKind.BUCKETING), False)self.assertEqual((query.call_args.kwargs["flag_key"], query.call_args.kwargs["window_start"]), ("renamed", changed_at[0]))@@ -200,7 +202,7 @@ class TestLoadFlagHistory(BaseTest):history, _ = self._load([False, False])assert isinstance(history, FlagHistory)- self.assertEqual(history.counted_split_changes, ())+ self.assertEqual(history.counted(SplitChange), ())@parameterized.expand([@@ -274,7 +276,7 @@ class TestLoadFlagHistory(BaseTest):assert isinstance(history, FlagHistoryNotChecked)self.assertEqual(history.reason, expected_reason)expected_changes = changed_at if can_read_flag_history else []- self.assertEqual([change.changed_at for change in history.split_changes], expected_changes)+ self.assertEqual([change.changed_at for change in history.of_kind(SplitChange)], expected_changes)self.assertEqual(query.call_count, 0)@parameterized.expand(@@ -298,7 +300,7 @@ class TestLoadFlagHistory(BaseTest):history, _ = self._load([], reader_access=reader_access)assert isinstance(history, FlagHistory)- self.assertEqual(history.counted_split_changes, ())+ self.assertEqual(history.counted(SplitChange), ())@parameterized.expand([@@ -314,7 +316,7 @@ class TestLoadFlagHistory(BaseTest):history, query = self._load([True, False])assert isinstance(history, FlagHistory)- self.assertIs(history.split_exposed_between, False)+ self.assertIs(history.exposed_between.get(ExperimentHealthFlagChangeKind.SPLIT), False)self.assertEqual(query.call_args.kwargs,{@@ -343,7 +345,7 @@ class TestLoadFlagHistory(BaseTest):next_load, next_query = self._load([True])assert isinstance(history, FlagHistory) and isinstance(next_load, FlagHistory)- self.assertEqual([change.changed_at for change in history.counted_split_changes], changed_at[1:])+ self.assertEqual([change.changed_at for change in history.counted(SplitChange)], changed_at[1:])self.assertIsNone(history.exposed_before_first)self.assertIsNone(next_load.exposed_before_first)self.assertEqual(next_query.call_count, 0)@@ -373,7 +375,7 @@ class TestLoadFlagHistory(BaseTest):assert isinstance(history, FlagHistory)self.assertEqual(query.call_count, expected_queries)- self.assertEqual(history.counted_split_changes[0].changed_at, changed_at[expected_queries])+ self.assertEqual(history.counted(SplitChange)[0].changed_at, changed_at[expected_queries])self.assertIsNone(history.exposed_before_first)def test_cached_walk_reads_the_cache_once(self) -> None:@@ -384,7 +386,7 @@ class TestLoadFlagHistory(BaseTest):history, query = self._load([])assert isinstance(history, FlagHistory)- self.assertEqual(history.counted_split_changes, ())+ self.assertEqual(history.counted(SplitChange), ())self.assertEqual(query.call_count, 0)self.assertEqual((cache_spy.get_many.call_count, cache_spy.get.call_count), (1, 0))@@ -418,7 +420,7 @@ class TestLoadFlagHistory(BaseTest):history, query = self._load([True])assert isinstance(history, FlagHistory)- self.assertIsNone(history.split_exposed_between)+ self.assertIsNone(history.exposed_between.get(ExperimentHealthFlagChangeKind.SPLIT))self.assertEqual(query.call_count, 1)diff --git a/products/experiments/backend/health/test/test_flag_state.py b/products/experiments/backend/health/test/test_flag_state.pyindex f2426ebf7a51..ef213d18e3fc 100644--- a/products/experiments/backend/health/test/test_flag_state.py+++ b/products/experiments/backend/health/test/test_flag_state.py@@ -1,3 +1,4 @@+from dataclasses import replacefrom typing import Anyfrom unittest import TestCase@@ -7,6 +8,7 @@ from parameterized import parameterizedfrom products.experiments.backend.facade.contracts import ExperimentHealthFindingCodefrom products.experiments.backend.health.checks.flag_state import flag_statefrom products.experiments.backend.health.context import HealthContext, parse_flag_state+from products.experiments.backend.health.test.factories import DRAFT, ENDED, RUNNING, RUNNING_CONTEXT, Status# The flag documents and cases of the `experimentWarning` test in# frontend/src/scenes/experiments/experimentLogic.test.ts, so that both sides answer alike. A running@@ -40,15 +42,12 @@ SHIPPED_TO_SOME = {"multivariate": SHIPPED_VARIANT["multivariate"],}-RUNNING = {"is_launched": True, "is_running": True, "has_ended": False}-ENDED = {"is_launched": True, "is_running": False, "has_ended": True}-DRAFT = {"is_launched": False, "is_running": False, "has_ended": False}-def _context(- status: dict[str, bool], *, active: bool, filters: dict[str, Any], deleted: bool = False, archived: bool = False+ status: Status, *, active: bool, filters: dict[str, Any], deleted: bool = False, archived: bool = False) -> HealthContext:- return HealthContext(+ return replace(+ RUNNING_CONTEXT,**status,is_paused=status["is_running"] and not active,archived=archived,@@ -58,13 +57,6 @@ def _context(groups=filters.get("groups"),variants=(filters.get("multivariate") or {}).get("variants"),),- baseline_variant_key=None,- primary_metric_count=1,- secondary_metric_count=0,- exposures=None,- flag_history=None,- condition_set_traffic=None,- excluded_variant_keys=frozenset(),)diff --git a/products/experiments/backend/health/test/test_flag_variants.py b/products/experiments/backend/health/test/test_flag_variants.pyindex ec1600c7f9b9..cb4b314373b1 100644--- a/products/experiments/backend/health/test/test_flag_variants.py+++ b/products/experiments/backend/health/test/test_flag_variants.py@@ -1,3 +1,4 @@+from dataclasses import replacefrom typing import Anyfrom unittest import TestCase@@ -7,26 +8,23 @@ from parameterized import parameterizedfrom products.experiments.backend.facade.contracts import ExperimentHealthFindingCodefrom products.experiments.backend.health.checks.flag_variants import flag_variants_mismatchfrom products.experiments.backend.health.context import HealthContext, parse_flag_state+from products.experiments.backend.health.test.factories import DRAFT, ENDED, RUNNING, RUNNING_CONTEXT, StatusEVEN_SPLIT = [{"key": "control", "rollout_percentage": 50}, {"key": "test", "rollout_percentage": 50}]NO_CONTROL_SPLIT = [{"key": "a", "rollout_percentage": 50}, {"key": "b", "rollout_percentage": 50}]-RUNNING = {"is_launched": True, "is_running": True, "has_ended": False}-ENDED = {"is_launched": True, "is_running": False, "has_ended": True}-DRAFT = {"is_launched": False, "is_running": False, "has_ended": False}-def _context(- status: dict[str, bool],+ status: Status,*,variants: list[dict[str, Any]] | None = EVEN_SPLIT,baseline: str | None = None,deleted: bool = False,archived: bool = False,) -> HealthContext:- return HealthContext(+ return replace(+ RUNNING_CONTEXT,**status,- is_paused=False,archived=archived,flag=parse_flag_state(active=True,@@ -35,12 +33,6 @@ def _context(variants=variants,),baseline_variant_key=baseline,- primary_metric_count=1,- secondary_metric_count=0,- exposures=None,- flag_history=None,- condition_set_traffic=None,- excluded_variant_keys=frozenset(),)diff --git a/products/experiments/backend/health/test/test_forced_variant.py b/products/experiments/backend/health/test/test_forced_variant.pyindex 6790eb6c75da..57f9fd95cac2 100644--- a/products/experiments/backend/health/test/test_forced_variant.py+++ b/products/experiments/backend/health/test/test_forced_variant.py@@ -1,3 +1,4 @@+from dataclasses import replacefrom datetime import UTC, datetimefrom typing import Any@@ -11,6 +12,7 @@ from products.experiments.backend.health.checks.forced_variant import (needs_condition_set_traffic,)from products.experiments.backend.health.context import ConditionSetTraffic, HealthContext, parse_flag_state+from products.experiments.backend.health.test.factories import DRAFT, ENDED, RUNNING, RUNNING_CONTEXT, StatusEVEN_SPLIT = [{"key": "control", "rollout_percentage": 50}, {"key": "test", "rollout_percentage": 50}]SHIPPED_SPLIT = [{"key": "control", "rollout_percentage": 0}, {"key": "test", "rollout_percentage": 100}]@@ -25,31 +27,21 @@ IOS: dict[str, Any] = {"rollout_percentage": 100,}-RUNNING = {"is_launched": True, "is_running": True, "has_ended": False}-ENDED = {"is_launched": True, "is_running": False, "has_ended": True}-DRAFT = {"is_launched": False, "is_running": False, "has_ended": False}-def _context(groups: list[dict[str, Any]],*,- status: dict[str, bool] = RUNNING,+ status: Status = RUNNING,variants: list[dict[str, Any]] = EVEN_SPLIT,deleted: bool = False,early_exit: bool = False,traffic: ConditionSetTraffic | None = None,excluded: frozenset[str] = frozenset(),) -> HealthContext:- return HealthContext(+ return replace(+ RUNNING_CONTEXT,**status,- is_paused=False,- archived=False,flag=parse_flag_state(active=True, deleted=deleted, groups=groups, variants=variants, early_exit=early_exit),- baseline_variant_key=None,- primary_metric_count=1,- secondary_metric_count=0,- exposures=None,- flag_history=None,condition_set_traffic=traffic,excluded_variant_keys=excluded,)diff --git a/products/experiments/backend/health/test/test_no_metric.py b/products/experiments/backend/health/test/test_no_metric.pyindex 09a2f3b06682..0977d2bc473c 100644--- a/products/experiments/backend/health/test/test_no_metric.py+++ b/products/experiments/backend/health/test/test_no_metric.py@@ -1,3 +1,4 @@+from dataclasses import replacefrom typing import Anyfrom unittest import TestCase@@ -7,25 +8,11 @@ from parameterized import parameterizedfrom products.experiments.backend.facade.contracts import ExperimentHealthFindingCodefrom products.experiments.backend.health.checks.no_metric import no_metricfrom products.experiments.backend.health.context import HealthContext+from products.experiments.backend.health.test.factories import RUNNING_CONTEXTdef _context(**changes: Any) -> HealthContext:- values: dict[str, Any] = {- "is_launched": True,- "is_running": True,- "has_ended": False,- "is_paused": False,- "archived": False,- "flag": None,- "baseline_variant_key": None,- "primary_metric_count": 0,- "secondary_metric_count": 0,- "exposures": None,- "flag_history": None,- "condition_set_traffic": None,- "excluded_variant_keys": frozenset(),- }- return HealthContext(**{**values, **changes})+ return replace(RUNNING_CONTEXT, **{"primary_metric_count": 0, **changes})class TestNoMetric(TestCase):diff --git a/products/experiments/backend/health/test/test_registry.py b/products/experiments/backend/health/test/test_registry.pyindex 02ae4156c059..a44872382a0e 100644--- a/products/experiments/backend/health/test/test_registry.py+++ b/products/experiments/backend/health/test/test_registry.py@@ -13,6 +13,7 @@ from products.experiments.backend.health import registryfrom products.experiments.backend.health.checks.bias_risk import bias_risk_multiple_excludedfrom products.experiments.backend.health.context import ExposureTotals, FlagState, FlagVariant, HealthContextfrom products.experiments.backend.health.registry import EXPOSURE_HEALTH_CHECKS, evaluate+from products.experiments.backend.health.test.factories import RUNNING_CONTEXTUNEVEN_SPLIT_TOTALS = ExposureTotals(total_exposures={"control": 800, "test": 200, "$multiple": 20},@@ -21,12 +22,8 @@ UNEVEN_SPLIT_TOTALS = ExposureTotals(hours_since_launch=72,)-RUNNING_UNEVEN_SPLIT = HealthContext(- is_launched=True,- is_running=True,- has_ended=False,- is_paused=False,- archived=False,+RUNNING_UNEVEN_SPLIT = replace(+ RUNNING_CONTEXT,flag=FlagState(active=True,deleted=False,@@ -37,13 +34,7 @@ RUNNING_UNEVEN_SPLIT = HealthContext(),reachable_conditions=(),),- baseline_variant_key=None,- primary_metric_count=1,- secondary_metric_count=0,exposures=UNEVEN_SPLIT_TOTALS,- flag_history=None,- condition_set_traffic=None,- excluded_variant_keys=frozenset(),)NO_EXPOSURES = replace(UNEVEN_SPLIT_TOTALS, total_exposures={"control": 0, "test": 0})diff --git a/products/experiments/backend/health/test/test_split_changed.py b/products/experiments/backend/health/test/test_split_changed.pyindex 4fdc06fa4ad7..7d38fbbb57fc 100644--- a/products/experiments/backend/health/test/test_split_changed.py+++ b/products/experiments/backend/health/test/test_split_changed.py@@ -1,3 +1,4 @@+from dataclasses import replacefrom datetime import UTC, datetime, timedeltafrom typing import Any@@ -6,21 +7,23 @@ from unittest import TestCasefrom parameterized import parameterizedfrom products.experiments.backend.facade.contracts import (+ ExperimentHealthFinding,ExperimentHealthFindingActionKind,ExperimentHealthFindingCode,ExperimentHealthFindingSeverity,+ ExperimentHealthFlagChangeKind,)+from products.experiments.backend.health.checks.flag_change_findings import flag_history_not_readablefrom products.experiments.backend.health.checks.flag_state import flag_statefrom products.experiments.backend.health.checks.split_changed import split_changed_mid_runfrom products.experiments.backend.health.context import (- FlagHistory,- FlagHistoryNotChecked,FlagHistoryNotCheckedReason,HealthContext,SplitChange,parse_flag_state,parse_variants,)+from products.experiments.backend.health.test.factories import ENDED, RUNNING, RUNNING_CONTEXT, Status, flag_historyLAUNCHED_AT = datetime(2026, 9, 12, 10, 0, tzinfo=UTC)FIRST_CHANGE_AT = datetime(2026, 9, 12, 13, 4, tzinfo=UTC)@@ -32,9 +35,6 @@ MIXED_ASSIGNMENTS = "A sample ratio mismatch or users in more than one variant cEVERYONE = [{"properties": [], "rollout_percentage": 100}]TARGETED = [{"properties": [{"key": "plan", "value": "pro", "type": "person"}], "rollout_percentage": 100}]-RUNNING = {"is_launched": True, "is_running": True, "has_ended": False}-ENDED = {"is_launched": True, "is_running": False, "has_ended": True}-def _split(*variants: tuple[str, float]) -> list[dict[str, Any]]:return [{"key": key, "rollout_percentage": share} for key, share in variants]@@ -49,7 +49,7 @@ SHIPPED = _split(("control", 0), ("test", 100))def _context(*splits: list[dict[str, Any]],- status: dict[str, bool] = RUNNING,+ status: Status = RUNNING,groups: list[dict[str, Any]] = EVERYONE,exposed_before_first: bool | None = True,exposed_between: bool | None = None,@@ -59,46 +59,34 @@ def _context(deleted: bool = False,not_checked: FlagHistoryNotCheckedReason | None = None,) -> HealthContext:- changes = tuple(+ changes = [SplitChange(changed_at=first_change_at + timedelta(minutes=17 * index),before=parse_variants(before),after=parse_variants(after),)for index, (before, after) in enumerate(zip(splits, splits[1:]))- )- return HealthContext(+ ]+ return replace(+ RUNNING_CONTEXT,**status,- is_paused=False,archived=archived,flag=parse_flag_state(active=True, deleted=deleted, groups=groups, variants=splits[-1]),- baseline_variant_key=None,- primary_metric_count=1,- secondary_metric_count=0,- exposures=None,- flag_history=FlagHistory(+ flag_history=flag_history(+ changes,launched_at=launched_at,- team_timezone="Europe/Berlin",- split_changes=changes,- bucketing_changes=(),- counted_since=changes[0].changed_at if changes else None,exposed_before_first=exposed_before_first,- split_exposed_between=exposed_between,- bucketing_exposed_between=None,- )- if not_checked is None- else FlagHistoryNotChecked(- reason=not_checked,- launched_at=launched_at,- team_timezone="Europe/Berlin",- split_changes=changes,- bucketing_changes=(),+ exposed_between={ExperimentHealthFlagChangeKind.SPLIT: exposed_between},+ not_checked=not_checked,),- condition_set_traffic=None,- excluded_variant_keys=frozenset(),)+def _split_code_finding(ctx: HealthContext) -> ExperimentHealthFinding | None:+ # The registry runs both checks, and a history the reader can't view gets the split check's code.+ return flag_history_not_readable(ctx) or split_changed_mid_run(ctx)++class TestSplitChangedMidRun(TestCase):@parameterized.expand([@@ -274,7 +262,7 @@ class TestSplitChangedMidRun(TestCase):])def test_evidence(self, _name: str, ctx: HealthContext, expected: dict[str, Any]) -> None:- finding = split_changed_mid_run(ctx)+ finding = _split_code_finding(ctx)assert finding is not Noneself.assertEqual(finding.evidence, expected)@@ -335,7 +323,7 @@ class TestSplitChangedMidRun(TestCase):),expected_title: str = "Variant split changes were not checked",) -> None:- finding = split_changed_mid_run(ctx)+ finding = _split_code_finding(ctx)assert finding is not Noneself.assertEqual(@@ -365,7 +353,7 @@ class TestSplitChangedMidRun(TestCase):])def test_no_finding(self, _name: str, ctx: HealthContext) -> None:- self.assertIsNone(split_changed_mid_run(ctx))+ self.assertIsNone(_split_code_finding(ctx))@parameterized.expand([diff --git a/products/experiments/backend/presentation/serializers.py b/products/experiments/backend/presentation/serializers.pyindex 9e93094883da..0f8b4d228876 100644--- a/products/experiments/backend/presentation/serializers.py+++ b/products/experiments/backend/presentation/serializers.py@@ -48,6 +48,7 @@ from products.experiments.backend.facade.contracts import (ExperimentHealthFindingActionKind,ExperimentHealthFindingCode,ExperimentHealthFindingSeverity,+ ExperimentHealthFlagChangeKind,ExperimentHealthInputsTrafficStatus,HealthExposureInputsStatus,)@@ -3148,6 +3149,9 @@ class ExperimentHealthInputsFlagSerializer(serializers.Serializer):many=True, help_text="The flag's release conditions, in evaluation order.")variants = ExperimentHealthInputsVariantSerializer(many=True, help_text="The flag's variants and their split.")+ split_text = serializers.CharField(+ help_text="The split as text, in the form of a change's before and after, such as 'control 50%, test 50%'."+ )_COUNTED_HELP = (@@ -3156,30 +3160,32 @@ _COUNTED_HELP = ()-class ExperimentHealthInputsSplitChangeSerializer(serializers.Serializer):- changed_at = serializers.DateTimeField(help_text="When the flag's split changed.")- before = ExperimentHealthInputsVariantSerializer(many=True, help_text="The split before the change.")- after = ExperimentHealthInputsVariantSerializer(many=True, help_text="The split after the change.")- counted = serializers.BooleanField(help_text=_COUNTED_HELP)+_FLAG_CHANGE_KIND_HELP = (+ "The kind of change. A bucketing change is a change of a setting that decides the variant draw."+)-class ExperimentHealthInputsBucketingChangeSerializer(serializers.Serializer):- changed_at = serializers.DateTimeField(help_text="When the setting changed.")- setting = serializers.CharField(- help_text=(- "The flag setting that decides the variant draw: 'key', 'aggregation' (the group type the flag matches "- "by), 'bucketing_identifier' or 'experience_continuity' (persist the flag across authentication steps)."- )- )+class ExperimentHealthInputsFlagChangeSerializer(serializers.Serializer):+ kind = serializers.ChoiceField(choices=ExperimentHealthFlagChangeKind.choices, help_text=_FLAG_CHANGE_KIND_HELP)+ changed_at = serializers.DateTimeField(help_text="When the flag changed.")+ changed = serializers.CharField(help_text="What changed: 'Split', or the name of the setting, such as 'Key'.")before = serializers.CharField(+ help_text="The value before the change as text, such as 'control 50%, test 50%' or 'device_id'. 'none' when unset."+ )+ after = serializers.CharField(help_text="The value after the change, in the same form.")+ counted = serializers.BooleanField(help_text=_COUNTED_HELP)+++class ExperimentHealthInputsExposedBetweenSerializer(serializers.Serializer):+ kind = serializers.ChoiceField(choices=ExperimentHealthFlagChangeKind.choices, help_text=_FLAG_CHANGE_KIND_HELP)+ question = serializers.CharField(help_text="What was asked, as the staff view names it.")+ exposed = serializers.BooleanField(allow_null=True,help_text=(- "The value before the change: the key, the group type index, 'distinct_id' or 'device_id', or 'true' or "- "'false'. Null for an aggregation by persons, or an unreadable key."+ "Whether anyone was exposed between the first and the last counted change of this kind. Asked only when "+ "the last sets back what the first changed. Null when not asked or unknown."),)- after = serializers.CharField(allow_null=True, help_text="The value after the change, in the same form.")- counted = serializers.BooleanField(help_text=_COUNTED_HELP)class ExperimentHealthInputsFlagHistorySerializer(serializers.Serializer):@@ -3195,34 +3201,19 @@ class ExperimentHealthInputsFlagHistorySerializer(serializers.Serializer):)launched_at = serializers.DateTimeField(help_text="When the experiment launched.")team_timezone = serializers.CharField(help_text="The project's time zone, which the findings use for times.")- split_changes = ExperimentHealthInputsSplitChangeSerializer(- many=True,- help_text="Every split change since launch. Empty for 'no_history_access', which does not read them.",- )- bucketing_changes = ExperimentHealthInputsBucketingChangeSerializer(+ changes = ExperimentHealthInputsFlagChangeSerializer(many=True,help_text=(- "Every change since launch of a setting that decides the variant draw, one per setting and save. Empty "- "for 'no_history_access'."+ "Every change since launch that can move exposed people, of every kind, in time order. A bucketing change "+ "is one per setting and save. Empty for 'no_history_access', which does not read them."),)exposed_before_first = serializers.BooleanField(allow_null=True,help_text="Whether anyone was exposed before the first counted change. Null when unknown or not checked.",)- split_exposed_between = serializers.BooleanField(- allow_null=True,- help_text=(- "Whether anyone was exposed between the first and the last counted split change. Asked only when the "- "last restores the split from before the first. Null when not asked or unknown."- ),- )- bucketing_exposed_between = serializers.BooleanField(- allow_null=True,- help_text=(- "Whether anyone was exposed between the first and the last counted bucketing change. Asked only when "- "every setting was set back. Null when not asked or unknown."- ),+ exposed_between = ExperimentHealthInputsExposedBetweenSerializer(+ many=True, help_text="One entry for each kind of change with a counted change, in the order of the kinds.")diff --git a/products/experiments/backend/test/test_presentation_api.py b/products/experiments/backend/test/test_presentation_api.pyindex 9377faceaadf..995f4701cc4e 100644--- a/products/experiments/backend/test/test_presentation_api.py+++ b/products/experiments/backend/test/test_presentation_api.py@@ -1089,10 +1089,14 @@ class TestExperimentCRUD(_HoistFlagConfigClientMixin, APILicensedTest):(history["checked"],history["not_checked_reason"],- [change["counted"] for change in history["split_changes"]],+ [change["counted"] for change in history["changes"]],),expected,)+ self.assertEqual(+ [(change["kind"], change["changed"], change["before"], change["after"]) for change in history["changes"]],+ [("split", "Split", "control 50%, test 50%", "control 80%, test 20%")] if rebalance else [],+ )def _deny_event_property(self, name: str) -> None:self.organization.available_product_features = [diff --git a/products/experiments/frontend/generated/api.schemas.ts b/products/experiments/frontend/generated/api.schemas.tsindex 107037fef9dd..7169893c909e 100644--- a/products/experiments/frontend/generated/api.schemas.ts+++ b/products/experiments/frontend/generated/api.schemas.ts@@ -3059,36 +3059,53 @@ export interface ExperimentHealthInputsFlagApi {release_conditions: ExperimentHealthInputsReleaseConditionApi[]/** The flag's variants and their split. */variants: ExperimentHealthInputsVariantApi[]+ /** The split as text, in the form of a change's before and after, such as 'control 50%, test 50%'. */+ split_text: string}-export interface ExperimentHealthInputsSplitChangeApi {- /** When the flag's split changed. */+/**+ * * `split` - Split+ * * `bucketing` - Bucketing+ */+export type ExperimentHealthFlagChangeKindEnumApi =+ (typeof ExperimentHealthFlagChangeKindEnumApi)[keyof typeof ExperimentHealthFlagChangeKindEnumApi]++export const ExperimentHealthFlagChangeKindEnumApi = {+ Split: 'split',+ Bucketing: 'bucketing',+} as const++export interface ExperimentHealthInputsFlagChangeApi {+ /** The kind of change. A bucketing change is a change of a setting that decides the variant draw.+ *+ * * `split` - Split+ * * `bucketing` - Bucketing */+ kind: ExperimentHealthFlagChangeKindEnumApi+ /** When the flag changed. */changed_at: string- /** The split before the change. */- before: ExperimentHealthInputsVariantApi[]- /** The split after the change. */- after: ExperimentHealthInputsVariantApi[]+ /** What changed: 'Split', or the name of the setting, such as 'Key'. */+ changed: string+ /** The value before the change as text, such as 'control 50%, test 50%' or 'device_id'. 'none' when unset. */+ before: string+ /** The value after the change, in the same form. */+ after: string/** Whether the checks count this change: every change counts from the first change, of any kind, with an exposure before it, or an unknown answer. False for every change when not checked. */counted: boolean}-export interface ExperimentHealthInputsBucketingChangeApi {- /** When the setting changed. */- changed_at: string- /** The flag setting that decides the variant draw: 'key', 'aggregation' (the group type the flag matches by), 'bucketing_identifier' or 'experience_continuity' (persist the flag across authentication steps). */- setting: string- /**- * The value before the change: the key, the group type index, 'distinct_id' or 'device_id', or 'true' or 'false'. Null for an aggregation by persons, or an unreadable key.- * @nullable- */- before: string | null+export interface ExperimentHealthInputsExposedBetweenApi {+ /** The kind of change. A bucketing change is a change of a setting that decides the variant draw.+ *+ * * `split` - Split+ * * `bucketing` - Bucketing */+ kind: ExperimentHealthFlagChangeKindEnumApi+ /** What was asked, as the staff view names it. */+ question: string/**- * The value after the change, in the same form.+ * Whether anyone was exposed between the first and the last counted change of this kind. Asked only when the last sets back what the first changed. Null when not asked or unknown.* @nullable*/- after: string | null- /** Whether the checks count this change: every change counts from the first change, of any kind, with an exposure before it, or an unknown answer. False for every change when not checked. */- counted: boolean+ exposed: boolean | null}export interface ExperimentHealthInputsFlagHistoryApi {@@ -3103,25 +3120,15 @@ export interface ExperimentHealthInputsFlagHistoryApi {launched_at: string/** The project's time zone, which the findings use for times. */team_timezone: string- /** Every split change since launch. Empty for 'no_history_access', which does not read them. */- split_changes: ExperimentHealthInputsSplitChangeApi[]- /** Every change since launch of a setting that decides the variant draw, one per setting and save. Empty for 'no_history_access'. */- bucketing_changes: ExperimentHealthInputsBucketingChangeApi[]+ /** Every change since launch that can move exposed people, of every kind, in time order. A bucketing change is one per setting and save. Empty for 'no_history_access', which does not read them. */+ changes: ExperimentHealthInputsFlagChangeApi[]/*** Whether anyone was exposed before the first counted change. Null when unknown or not checked.* @nullable*/exposed_before_first: boolean | null- /**- * Whether anyone was exposed between the first and the last counted split change. Asked only when the last restores the split from before the first. Null when not asked or unknown.- * @nullable- */- split_exposed_between: boolean | null- /**- * Whether anyone was exposed between the first and the last counted bucketing change. Asked only when every setting was set back. Null when not asked or unknown.- * @nullable- */- bucketing_exposed_between: boolean | null+ /** One entry for each kind of change with a counted change, in the order of the kinds. */+ exposed_between: ExperimentHealthInputsExposedBetweenApi[]}/**diff --git a/products/experiments/frontend/health/debug/healthDebugInputs.ts b/products/experiments/frontend/health/debug/healthDebugInputs.tsindex c348e349d16b..b76daccc2771 100644--- a/products/experiments/frontend/health/debug/healthDebugInputs.ts+++ b/products/experiments/frontend/health/debug/healthDebugInputs.ts@@ -5,9 +5,7 @@ import { getExperimentStatus } from '../../experimentStatus'import type {ExperimentHealthInputsApi,ExperimentHealthInputsExposuresApi,- ExperimentHealthInputsFlagHistoryApi,ExperimentHealthInputsTrafficStatusEnumApi,- ExperimentHealthInputsVariantApi,HealthExposureInputsStatusEnumApi,} from '../../generated/api.schemas'import type { SetupFact } from '../../setupInspector/SetupFactsTable'@@ -53,16 +51,6 @@ function serverValue(state: HealthInputsState, read: (inputs: ExperimentHealthInreturn state.error ? `Not loaded: ${state.error}` : 'Not loaded'}-function percentage(value: number | null): string {- return value === null ? 'unset' : `${value}%`-}--export function describeSplit(variants: ExperimentHealthInputsVariantApi[]): string {- return variants.length- ? variants.map((variant) => `${variant.key ?? 'no key'} ${percentage(variant.rollout_percentage)}`).join(', ')- : 'none'-}-function yesNoUnknown(value: boolean | null): string {return value === null ? 'Unknown' : formatYesNo(value)}@@ -134,7 +122,7 @@ export function buildFlagFacts(experiment: Experiment, state: HealthInputsState)},{label: 'Variants',- value: serverValue(state, ({ flag }) => (flag ? describeSplit(flag.variants) : 'No flag')),+ value: serverValue(state, ({ flag }) => (flag ? flag.split_text : 'No flag')),},]}@@ -152,17 +140,13 @@ export function buildReleaseConditions(inputs: ExperimentHealthInputsApi | null)}))}-function allFlagChanges(history: ExperimentHealthInputsFlagHistoryApi): { counted: boolean }[] {- return [...history.split_changes, ...history.bucketing_changes]-}-function describeFlagHistoryStatus(inputs: ExperimentHealthInputsApi): string {const history = inputs.flag_historyif (history) {if (!history.checked) {return `Not compared: ${history.not_checked_reason}`}- const changes = allFlagChanges(history)+ const changes = history.changesconst total = changes.lengthconst counted = changes.filter((change) => change.counted).lengthif (total === 0) {@@ -189,18 +173,9 @@ function describeFlagHistoryStatus(inputs: ExperimentHealthInputsApi): string {return 'Not read: the read failed'}-const SET_BACK_FACTS = [- { kind: 'split_changes', field: 'split_exposed_between', label: 'Exposed between the first and last split change' },- {- kind: 'bucketing_changes',- field: 'bucketing_exposed_between',- label: 'Exposed between the first and last bucketing change',- },-] as const-export function buildFlagHistoryFacts(state: HealthInputsState): SetupFact[] {const history = state.inputs?.flag_history ?? null- const hasCountedChange = !!history && allFlagChanges(history).some((change) => change.counted)+ const hasCountedChange = !!history && history.changes.some((change) => change.counted)return [{label: 'Status',@@ -216,49 +191,24 @@ export function buildFlagHistoryFacts(state: HealthInputsState): SetupFact[] {label: 'Exposed before the first counted change',value: yesNoUnknown(history.exposed_before_first),},- ...SET_BACK_FACTS.filter(({ kind }) => history[kind].some((change) => change.counted)).map(- ({ field, label }) => ({- label,- value: yesNoUnknown(history[field]),- help: 'Asked only when the last counted change of this kind sets back what the first changed.',- })- ),+ ...history.exposed_between.map(({ question, exposed }) => ({+ label: question,+ value: yesNoUnknown(exposed),+ help: 'Asked only when the last counted change of this kind sets back what the first changed.',+ })),]: []),]}-const BUCKETING_SETTING_LABELS: Record<string, string> = {- key: 'Key',- aggregation: 'Match by group type',- bucketing_identifier: 'Bucketing identifier',- experience_continuity: 'Persist across authentication',-}-export function buildFlagChanges(inputs: ExperimentHealthInputsApi | null): HealthDebugFlagChange[] {- const history = inputs?.flag_history- if (!history) {- return []- }- const changes = [- ...history.split_changes.map((change) => ({- at: change.changed_at,- changed: 'Split',- before: describeSplit(change.before),- after: describeSplit(change.after),- counted: change.counted,- })),- ...history.bucketing_changes.map((change) => ({- at: change.changed_at,- changed: BUCKETING_SETTING_LABELS[change.setting] ?? change.setting,- before: change.before ?? 'none',- after: change.after ?? 'none',- counted: change.counted,- })),- ]- return changes- .sort((a, b) => new Date(a.at).getTime() - new Date(b.at).getTime())- .map(({ at, ...change }) => ({ changedAt: formatTimestamp(at), ...change }))+ return (inputs?.flag_history?.changes ?? []).map((change) => ({+ changedAt: formatTimestamp(change.changed_at),+ changed: change.changed,+ before: change.before,+ after: change.after,+ counted: change.counted,+ }))}const TRAFFIC_STATUS_LABELS: Record<ExperimentHealthInputsTrafficStatusEnumApi, string> = {diff --git a/services/mcp/src/api/generated.ts b/services/mcp/src/api/generated.tsindex 9d1f01457765..d07ab5c16f29 100644--- a/services/mcp/src/api/generated.ts+++ b/services/mcp/src/api/generated.ts@@ -45313,6 +45313,18 @@ export namespace Schemas {can_view_task: boolean;}+ /**+ * * `split` - Split+ * * `bucketing` - Bucketing+ */+ export type ExperimentHealthFlagChangeKindEnum = typeof ExperimentHealthFlagChangeKindEnum[keyof typeof ExperimentHealthFlagChangeKindEnum];+++ export const ExperimentHealthFlagChangeKindEnum = {+ Split: 'split',+ Bucketing: 'bucketing',+ } as const;+export interface ExperimentHealthInputsReleaseCondition {/** The condition's position in the flag, from 1, as the flag page labels it ('Set 2'). */number: number;@@ -45357,36 +45369,41 @@ export namespace Schemas {release_conditions: ExperimentHealthInputsReleaseCondition[];/** The flag's variants and their split. */variants: ExperimentHealthInputsVariant[];+ /** The split as text, in the form of a change's before and after, such as 'control 50%, test 50%'. */+ split_text: string;}- export interface ExperimentHealthInputsSplitChange {- /** When the flag's split changed. */+ export interface ExperimentHealthInputsFlagChange {+ /** The kind of change. A bucketing change is a change of a setting that decides the variant draw.+ *+ * * `split` - Split+ * * `bucketing` - Bucketing */+ kind: ExperimentHealthFlagChangeKindEnum;+ /** When the flag changed. */changed_at: string;- /** The split before the change. */- before: ExperimentHealthInputsVariant[];- /** The split after the change. */- after: ExperimentHealthInputsVariant[];+ /** What changed: 'Split', or the name of the setting, such as 'Key'. */+ changed: string;+ /** The value before the change as text, such as 'control 50%, test 50%' or 'device_id'. 'none' when unset. */+ before: string;+ /** The value after the change, in the same form. */+ after: string;/** Whether the checks count this change: every change counts from the first change, of any kind, with an exposure before it, or an unknown answer. False for every change when not checked. */counted: boolean;}- export interface ExperimentHealthInputsBucketingChange {- /** When the setting changed. */- changed_at: string;- /** The flag setting that decides the variant draw: 'key', 'aggregation' (the group type the flag matches by), 'bucketing_identifier' or 'experience_continuity' (persist the flag across authentication steps). */- setting: string;- /**- * The value before the change: the key, the group type index, 'distinct_id' or 'device_id', or 'true' or 'false'. Null for an aggregation by persons, or an unreadable key.- * @nullable- */- before: string | null;+ export interface ExperimentHealthInputsExposedBetween {+ /** The kind of change. A bucketing change is a change of a setting that decides the variant draw.+ *+ * * `split` - Split+ * * `bucketing` - Bucketing */+ kind: ExperimentHealthFlagChangeKindEnum;+ /** What was asked, as the staff view names it. */+ question: string;/**- * The value after the change, in the same form.+ * Whether anyone was exposed between the first and the last counted change of this kind. Asked only when the last sets back what the first changed. Null when not asked or unknown.* @nullable*/- after: string | null;- /** Whether the checks count this change: every change counts from the first change, of any kind, with an exposure before it, or an unknown answer. False for every change when not checked. */- counted: boolean;+ exposed: boolean | null;}export interface ExperimentHealthInputsFlagHistory {@@ -45401,25 +45418,15 @@ export namespace Schemas {launched_at: string;/** The project's time zone, which the findings use for times. */team_timezone: string;- /** Every split change since launch. Empty for 'no_history_access', which does not read them. */- split_changes: ExperimentHealthInputsSplitChange[];- /** Every change since launch of a setting that decides the variant draw, one per setting and save. Empty for 'no_history_access'. */- bucketing_changes: ExperimentHealthInputsBucketingChange[];+ /** Every change since launch that can move exposed people, of every kind, in time order. A bucketing change is one per setting and save. Empty for 'no_history_access', which does not read them. */+ changes: ExperimentHealthInputsFlagChange[];/*** Whether anyone was exposed before the first counted change. Null when unknown or not checked.* @nullable*/exposed_before_first: boolean | null;- /**- * Whether anyone was exposed between the first and the last counted split change. Asked only when the last restores the split from before the first. Null when not asked or unknown.- * @nullable- */- split_exposed_between: boolean | null;- /**- * Whether anyone was exposed between the first and the last counted bucketing change. Asked only when every setting was set back. Null when not asked or unknown.- * @nullable- */- bucketing_exposed_between: boolean | null;+ /** One entry for each kind of change with a counted change, in the order of the kinds. */+ exposed_between: ExperimentHealthInputsExposedBetween[];}/**