:hedgehog: PostHog is the leading platform for building self-driving products. Our developer tools – AI observability, analytics, session replay, flags, experiments, error tracking, logs, and more – capture all the context agents need to diagnose problems, uncover opportunities, and ship fixes. Steer it all from Slack, web, desktop, or the MCP.
Python ab-testingai-analyticsanalyticscdpdata-warehouseexperimentsfeature-flagsjavascriptproduct-analyticspythonreactsession-replaysurveystypescriptweb-analytics
feat(signals): add stable percentage enrollment to activity summary generation (#122723)
posthog[bot]28b62672e621
diff --git a/products/replay_vision/backend/facade/api.py b/products/replay_vision/backend/facade/api.pyindex 5270b42d4489..3a2bdd06e637 100644--- a/products/replay_vision/backend/facade/api.py+++ b/products/replay_vision/backend/facade/api.py@@ -183,6 +183,11 @@ def has_signal_emitting_scanner(team_id: int) -> bool:return ReplayScanner.objects.filter(team_id=team_id, enabled=True, emits_signals=True).exists()+def team_ids_with_signal_emitting_scanner() -> set[int]:+ """Every team that `has_signal_emitting_scanner` is true for, in one query."""+ return set(ReplayScanner.objects.filter(enabled=True, emits_signals=True).values_list("team_id", flat=True))++def start_workflow_observation_request(*,team_id: int,diff --git a/products/signals/backend/activity_summary/config.py b/products/signals/backend/activity_summary/config.pyindex b4f710115980..60fd0c8dd561 100644--- a/products/signals/backend/activity_summary/config.py+++ b/products/signals/backend/activity_summary/config.py@@ -36,6 +36,11 @@ class ActivitySummaryConfig:# Enrolls every organization with AI data processing approval. Otherwise only `organization_ids`.enroll_all_approved: bool = Falseorganization_ids: tuple[str, ...] = ()+ # Generates for this percentage of the organizations with a project that has an enabled signal source.+ # Only those projects get summaries. A higher percentage keeps the organizations of a lower one.+ self_driving_organization_percentage: float = 0.0+ # The tick never generates for these organizations, even when another field enrolls them.+ deny_organization_ids: tuple[str, ...] = ()skip_team_ids: tuple[int, ...] = ()max_pairs_per_tick: int = 50# Rolling 24 hours, counted from the stored rows, so the caps hold across ticks and workers.@@ -89,6 +94,12 @@ def _fraction(value: Any, default: float) -> float:return number if number <= 1 else default+def _percentage(value: Any, default: float) -> float:+ if isinstance(value, bool) or not isinstance(value, int | float) or not 0 <= value <= 100:+ return default+ return float(value)++def _bool(value: Any, default: bool) -> bool:return value if isinstance(value, bool) else default@@ -138,6 +149,10 @@ def parse_config(payload: Any) -> ActivitySummaryConfig:enabled=True,enroll_all_approved=_bool(payload.get("enroll_all_approved"), defaults.enroll_all_approved),organization_ids=_organization_ids(payload.get("organization_ids")),+ self_driving_organization_percentage=_percentage(+ payload.get("self_driving_organization_percentage"), defaults.self_driving_organization_percentage+ ),+ deny_organization_ids=_organization_ids(payload.get("deny_organization_ids")),skip_team_ids=_team_ids(payload.get("skip_team_ids")),max_pairs_per_tick=_positive_int(payload.get("max_pairs_per_tick"), defaults.max_pairs_per_tick),max_pairs_per_day=_positive_int(payload.get("max_pairs_per_day"), defaults.max_pairs_per_day),@@ -176,5 +191,7 @@ def read_config() -> ActivitySummaryConfig:enabled=config.enabled,enroll_all_approved=config.enroll_all_approved,organizations=len(config.organization_ids),+ self_driving_organization_percentage=config.self_driving_organization_percentage,+ denied_organizations=len(config.deny_organization_ids),)return configdiff --git a/products/signals/backend/activity_summary/logic.py b/products/signals/backend/activity_summary/logic.pyindex 3a6ed5d72db8..4fe64bc5d5b3 100644--- a/products/signals/backend/activity_summary/logic.py+++ b/products/signals/backend/activity_summary/logic.py@@ -61,6 +61,7 @@ class UpdateStatus(StrEnum):OK = "ok"FAILED = "failed"SKIPPED_AI_NOT_APPROVED = "skipped_ai_not_approved"+ SKIPPED_NOT_ENROLLED = "skipped_not_enrolled"SKIPPED_NOT_ELIGIBLE_YET = "skipped_not_eligible_yet"SKIPPED_TOO_FEW_UNITS = "skipped_too_few_units"diff --git a/products/signals/backend/activity_summary/queue.py b/products/signals/backend/activity_summary/queue.pyindex 0f999d2b7dfa..5d11e5f4b7bd 100644--- a/products/signals/backend/activity_summary/queue.py+++ b/products/signals/backend/activity_summary/queue.py@@ -9,6 +9,7 @@ rules and `min_units`, and backs a pair off when it skips, so the pair leaves thimport mathimport uuid+import hashlibimport datetimefrom collections.abc import Callablefrom typing import Any@@ -160,23 +161,75 @@ def daily_usage(now: datetime.datetime) -> DailyUsage:)+# A new salt reorders every organization, so change the version only to start a new rollout order.+_ROLLOUT_SALT = "activity-summary-self-driving-v1"+_ROLLOUT_BUCKETS = 10_000+++def organization_rollout_bucket(organization_id: uuid.UUID) -> int:+ """The organization's fixed place in the percentage rollout, from 0 to `_ROLLOUT_BUCKETS` - 1."""+ digest = hashlib.sha256(f"{_ROLLOUT_SALT}:{organization_id}".encode()).digest()+ return int.from_bytes(digest[:8], "big") % _ROLLOUT_BUCKETS+++def _in_rollout(config: ActivitySummaryConfig, organization_id: uuid.UUID) -> bool:+ threshold = config.self_driving_organization_percentage * _ROLLOUT_BUCKETS / 100+ return organization_rollout_bucket(organization_id) < threshold++def enrolled_team_ids(config: ActivitySummaryConfig) -> list[int]:- """The teams of every approved organization, or of the approved organizations in the allowlist."""- teams = Team.objects.filter(organization__is_ai_data_processing_approved=True)- if not config.enroll_all_approved:- if not config.organization_ids:- return []- teams = teams.filter(organization_id__in=config.organization_ids)- return list(teams.exclude(id__in=config.skip_team_ids).values_list("id", flat=True))+ """The teams that `is_team_enrolled_for_generation` enrolls, in a fixed number of queries."""+ if not config.enabled:+ return []+ listed = _parse_organization_ids(config.organization_ids)+ teams = (+ Team.objects.filter(organization__is_ai_data_processing_approved=True)+ .exclude(id__in=config.skip_team_ids)+ .exclude(organization_id__in=_parse_organization_ids(config.deny_organization_ids))+ )+ if config.enroll_all_approved:+ return sorted(teams.values_list("id", flat=True))+ team_ids = set(teams.filter(organization_id__in=listed).values_list("id", flat=True)) if listed else set()+ if config.self_driving_organization_percentage > 0:+ from products.signals.backend.facade.api import (+ team_ids_with_enabled_source, # noqa: PLC0415 — the facade imports this module through `read`+ )++ # The teams with an enabled source come first, because they are far fewer than the approved teams.+ candidates = teams.filter(id__in=team_ids_with_enabled_source()).exclude(organization_id__in=listed)+ team_ids |= {+ team_id+ for team_id, organization_id in candidates.values_list("id", "organization_id")+ if _in_rollout(config, organization_id)+ }+ return sorted(team_ids)def is_team_enrolled_for_generation(config: ActivitySummaryConfig, team: Team) -> bool:- """The tick may generate summaries for the team. It is the read check for now."""- return is_team_enrolled_for_read(config, team)+ """The tick may generate summaries for the team. The single-team form of `enrolled_team_ids`.++ The kill switch, `skip_team_ids`, AI data processing approval and the denylist win over every enrollment.+ The percentage rollout enrolls only the projects that have an enabled signal source.+ """+ if not config.enabled or team.id in config.skip_team_ids:+ return False+ if team.organization.is_ai_data_processing_approved is not True:+ return False+ if team.organization_id in _parse_organization_ids(config.deny_organization_ids):+ return False+ if config.enroll_all_approved or team.organization_id in _parse_organization_ids(config.organization_ids):+ return True+ if not _in_rollout(config, team.organization_id):+ return False+ from products.signals.backend.facade.api import (+ has_enabled_source, # noqa: PLC0415 — the facade imports this module through `read`+ )++ return has_enabled_source(team.id)def is_team_enrolled_for_read(config: ActivitySummaryConfig, team: Team) -> bool:- """The single-team form of `enrolled_team_ids`. The API and MCP tools read summaries only for these teams.+ """The API and MCP tools read summaries only for these teams. The percentage rollout and the denylist do not apply.A disabled config enrolls no team."""@@ -184,18 +237,18 @@ def is_team_enrolled_for_read(config: ActivitySummaryConfig, team: Team) -> boolreturn Falseif team.organization.is_ai_data_processing_approved is not True:return False- return config.enroll_all_approved or team.organization_id in _listed_organization_ids(config)+ return config.enroll_all_approved or team.organization_id in _parse_organization_ids(config.organization_ids)-def _listed_organization_ids(config: ActivitySummaryConfig) -> set[uuid.UUID]:- # The same parse as the `organization_id__in` filter, so an id in another UUID format still matches.- listed: set[uuid.UUID] = set()- for organization_id in config.organization_ids:+def _parse_organization_ids(organization_ids: tuple[str, ...]) -> set[uuid.UUID]:+ # A UUID parse, so an id in another UUID format still matches, and an invalid id matches nothing.+ parsed: set[uuid.UUID] = set()+ for organization_id in organization_ids:try:- listed.add(uuid.UUID(organization_id))+ parsed.add(uuid.UUID(organization_id))except ValueError:continue- return listed+ return parseddef _add(pending: _Pending, pair: ActivitySummaryPair, units: int, at: datetime.datetime) -> None:@@ -344,12 +397,13 @@ def _add_pending(pending: _Pending) -> None:)-def feed_queue(config: ActivitySummaryConfig, now: datetime.datetime) -> int:+def feed_queue(config: ActivitySummaryConfig, now: datetime.datetime, team_ids: list[int] | None = None) -> int:"""Move each source cursor forward and add the rows it passes to the queue state. Returns the pairs fed.A source with no cursor starts at the current end, so the backfill command seeds the earlier rows."""- team_ids = enrolled_team_ids(config)+ if team_ids is None:+ team_ids = enrolled_team_ids(config)end = now - FEED_LAGfed = 0for source in queue_sources(config):@@ -534,7 +588,9 @@ def _tier_stats(return stats-def select_pairs(config: ActivitySummaryConfig, now: datetime.datetime, limit: int) -> PairSelection:+def select_pairs(+ config: ActivitySummaryConfig, now: datetime.datetime, limit: int, team_ids: list[int] | None = None+) -> PairSelection:"""The due pairs of the enrolled teams, highest priority first, cut to `limit`.A pair is due when it has a row in the last `window_days` and its due time is empty or past. A pair@@ -546,7 +602,8 @@ def select_pairs(config: ActivitySummaryConfig, now: datetime.datetime, limit: ileast `max_overdue_factor` staleness, for `paying_budget_share` of `limit`. The second pass ranks theother free pairs for the budget that is left."""- team_ids = enrolled_team_ids(config)+ if team_ids is None:+ team_ids = enrolled_team_ids(config)if not team_ids:return PairSelection(pairs=[], due_pairs=0, tiers=[])states = _states(config, now, team_ids)diff --git a/products/signals/backend/activity_summary/tick.py b/products/signals/backend/activity_summary/tick.pyindex b3ea7973a074..443d9376e104 100644--- a/products/signals/backend/activity_summary/tick.py+++ b/products/signals/backend/activity_summary/tick.py@@ -41,7 +41,9 @@ from products.signals.backend.activity_summary.queue import (ActivitySummaryPair,ActivitySummaryTierStats,daily_usage,+ enrolled_team_ids,feed_queue,+ is_team_enrolled_for_generation,max_update_cost_usd,select_pairs,sync_pair_state,@@ -149,14 +151,16 @@ def plan_tick(limit: int | None, now: datetime.datetime) -> ActivitySummaryTickP# Every pair would fail on the same missing gateway, so the tick runs none.logger.warning("activity_summary_tick_gateway_not_configured")enabled = config.enabled and not gateway_missing+ # One enrollment read serves the feed and the selection.+ team_ids = enrolled_team_ids(config)if config.enabled:# The cursors move even when a cap stops the tick, so new rows do not pile up behind them.- feed_queue(config, now)+ feed_queue(config, now, team_ids)usage = daily_usage(now) if enabled else Noneupdates_left = max(0, config.max_pairs_per_day - usage.updates) if usage else 0cost_left = max(0.0, config.max_cost_usd_per_day - usage.cost_usd) if usage else 0.0tick_limit = limit or config.max_pairs_per_tick- selection = select_pairs(config, now, tick_limit) if updates_left and cost_left else None+ selection = select_pairs(config, now, tick_limit, team_ids) if updates_left and cost_left else Nonepairs = selection.pairs if selection else []due_pairs = selection.due_pairs if selection else 0@@ -243,7 +247,17 @@ def _capture_generated(team_id: int, user_id: int, update: ActivitySummaryUpdate)+def _enrolled_at_dispatch(team_id: int) -> bool:+ # The flag can change between the plan and the pair, so the pair reads it again.+ team = Team.objects.select_related("organization").filter(id=team_id).first()+ return team is not None and is_team_enrolled_for_generation(read_config(), team)++def run_pair(input: ActivitySummaryPairInput, *, last_attempt: bool = True) -> ActivitySummaryPairResult:+ if not _enrolled_at_dispatch(input.team_id):+ return ActivitySummaryPairResult(+ status=UpdateStatus.SKIPPED_NOT_ENROLLED.value, cost_usd=None, called_model=False+ )try:update = update_activity_summary(input.team_id,diff --git a/products/signals/backend/facade/api.py b/products/signals/backend/facade/api.pyindex e7b3d88d5ed1..3a0e2016f756 100644--- a/products/signals/backend/facade/api.py+++ b/products/signals/backend/facade/api.py@@ -8,7 +8,7 @@ from typing import TYPE_CHECKING, Anyfrom django.conf import settingsfrom django.db import transaction-from django.db.models import Q+from django.db.models import Q, QuerySetfrom django.utils import timezoneimport pydantic@@ -566,22 +566,35 @@ def waiting_reports(team_id: int, limit: int = 3) -> WaitingReports:)+def _enabled_source_configs() -> QuerySet[SignalSourceConfig]:+ return (+ SignalSourceConfig.objects.filter(enabled=True)+ # Retired: rows outlive the feature until the cleanup migration runs, and counting one marks+ # onboarding complete on a source that emits nothing.+ .exclude(source_product="session_replay", source_type="session_analysis_cluster")+ )++def has_enabled_source(team_id: int) -> bool:"""True once the team has at least one enabled signal source — i.e. there's something to respond to.Replay Vision is checked separately because it has no config row to find: each scanner's own`emits_signals` flag authorizes it (see `SignalSourceConfig.is_source_enabled`)."""- if (- SignalSourceConfig.objects.filter(team_id=team_id, enabled=True)- # Retired: rows outlive the feature until the cleanup migration runs, and counting one marks- # onboarding complete on a source that emits nothing.- .exclude(source_product="session_replay", source_type="session_analysis_cluster")- .exists()- ):+ if _enabled_source_configs().filter(team_id=team_id).exists():return Truereturn _has_emitting_replay_scanner(team_id)+def team_ids_with_enabled_source() -> set[int]:+ """Every team that `has_enabled_source` is true for, in two queries."""+ from products.replay_vision.backend.facade.api import (+ team_ids_with_signal_emitting_scanner, # noqa: PLC0415 — keeps the Replay Vision stack off this import path+ )++ with_config = set(_enabled_source_configs().values_list("team_id", flat=True))+ return with_config | team_ids_with_signal_emitting_scanner()++def organization_acted_on_report(organization_id: "str | uuid.UUID") -> bool:"""True once someone in the org has acted on a Self-driving report — resolved or dismissed one.diff --git a/products/signals/backend/test/test_activity_summary_tick.py b/products/signals/backend/test/test_activity_summary_tick.pyindex 1b98fd3fa968..f418fbe28bae 100644--- a/products/signals/backend/test/test_activity_summary_tick.py+++ b/products/signals/backend/test/test_activity_summary_tick.py@@ -37,6 +37,7 @@ from products.signals.backend.activity_summary.queue import (is_team_enrolled_for_generation,is_team_enrolled_for_read,max_update_cost_usd,+ organization_rollout_bucket,seed_queue,select_pairs,)@@ -61,7 +62,7 @@ from products.signals.backend.activity_summary.tick import (plan_tick,run_pair,)-from products.signals.backend.models import UserActivitySummary, UserActivitySummaryQueueState+from products.signals.backend.models import SignalSourceConfig, UserActivitySummary, UserActivitySummaryQueueStatefrom products.signals.backend.test.test_activity_summary_render import FakeLLMfrom products.tasks.backend.facade.user_task_summaries import UserTaskTime@@ -101,9 +102,16 @@ _CONFIG_CASES: list[tuple[str, Any, ActivitySummaryConfig]] = ["max_org_share": 2,"rebuild_budget_share": 2,"max_error_rate": 0,+ "self_driving_organization_percentage": 101,+ "deny_organization_ids": "org-b",},ActivitySummaryConfig(enabled=True, organization_ids=("org-a",), skip_team_ids=(3,)),),+ (+ "a boolean percentage falls back to the default",+ {"enabled": True, "self_driving_organization_percentage": True},+ ActivitySummaryConfig(enabled=True),+ ),("valid fields",{@@ -118,6 +126,8 @@ _CONFIG_CASES: list[tuple[str, Any, ActivitySummaryConfig]] = ["count_views": True,"target_interval_days_free": 7,"max_org_share": 0.3,+ "self_driving_organization_percentage": 12.5,+ "deny_organization_ids": ["org-b", 4],},ActivitySummaryConfig(enabled=True,@@ -131,6 +141,8 @@ _CONFIG_CASES: list[tuple[str, Any, ActivitySummaryConfig]] = [count_views=True,target_interval_days_free=7.0,max_org_share=0.3,+ self_driving_organization_percentage=12.5,+ deny_organization_ids=("org-b",),),),(@@ -165,8 +177,35 @@ def test_parse_config(_name: str, payload: Any, expected: ActivitySummaryConfig)assert parse_config(payload) == expected+ [+ ("canonical", "0188f3a2-5b7c-7d1e-9f00-123456789abc", 3211),+ ("upper case without hyphens", "0188F3A25B7C7D1E9F00123456789ABC", 3211),+ ("other organization", "00000000-0000-0000-0000-000000000001", 8554),+ ]+)+def test_the_rollout_bucket_of_an_organization_does_not_change(_name: str, organization_id: str, bucket: int) -> None:+ assert organization_rollout_bucket(uuid.UUID(organization_id)) == bucket++[email protected]([(10.0, 40.0), (40.0, 100.0)])+def test_a_higher_percentage_keeps_the_organizations_of_a_lower_one(lower: float, higher: float) -> None:+ organization_ids = [uuid.UUID(int=index * 7919) for index in range(500)]++ def members(percentage: float) -> set[uuid.UUID]:+ return {o for o in organization_ids if organization_rollout_bucket(o) < percentage * 100}++ assert members(lower) < members(higher)++@time_machine.travel(NOW, tick=False)class TestActivitySummaryQueue(BaseTest):+ def setUp(self) -> None:+ super().setUp()+ dispatch_config = patch.object(tick, "read_config", side_effect=lambda: self._config())+ dispatch_config.start()+ self.addCleanup(dispatch_config.stop)+def _config(self, **overrides: Any) -> ActivitySummaryConfig:return ActivitySummaryConfig(enabled=True, organization_ids=(str(self.organization.id),), **overrides)@@ -344,29 +383,152 @@ class TestActivitySummaryQueue(BaseTest):@parameterized.expand([- ("listed", {}, True, True),- ("disabled", {"enabled": False}, True, False),- ("not_listed", {"organization_ids": ("00000000-0000-0000-0000-000000000001",)}, True, False),- ("invalid_listed_id", {"organization_ids": ("not-a-uuid",)}, True, False),- ("team_skipped", {"skip_team_ids": ("own",)}, True, False),- ("not_approved", {}, False, False),- ("all_approved", {"organization_ids": (), "enroll_all_approved": True}, True, True),- ("all_approved_not_approved", {"organization_ids": (), "enroll_all_approved": True}, False, False),- ("all_approved_team_skipped", {"enroll_all_approved": True, "skip_team_ids": ("own",)}, True, False),+ ("listed", {}, True, False, True, True),+ ("disabled", {"enabled": False}, True, False, False, False),+ ("not_listed", {"organization_ids": ("00000000-0000-0000-0000-000000000001",)}, True, False, False, False),+ ("invalid_listed_id", {"organization_ids": ("not-a-uuid",)}, True, False, False, False),+ ("team_skipped", {"skip_team_ids": ("own",)}, True, False, False, False),+ ("not_approved", {}, False, False, False, False),+ ("all_approved", {"organization_ids": (), "enroll_all_approved": True}, True, False, True, True),+ (+ "all_approved_not_approved",+ {"organization_ids": (), "enroll_all_approved": True},+ False,+ False,+ False,+ False,+ ),+ (+ "all_approved_team_skipped",+ {"enroll_all_approved": True, "skip_team_ids": ("own",)},+ True,+ False,+ False,+ False,+ ),+ ("listed_and_denied", {"deny_organization_ids": ("own",)}, True, True, True, False),+ (+ "all_approved_and_denied",+ {"enroll_all_approved": True, "deny_organization_ids": ("own",)},+ True,+ True,+ True,+ False,+ ),+ (+ "rollout",+ {"organization_ids": (), "self_driving_organization_percentage": 100.0},+ True,+ True,+ False,+ True,+ ),+ (+ "rollout_without_source",+ {"organization_ids": (), "self_driving_organization_percentage": 100.0},+ True,+ False,+ False,+ False,+ ),+ (+ "rollout_at_zero",+ {"organization_ids": (), "self_driving_organization_percentage": 0.0},+ True,+ True,+ False,+ False,+ ),+ (+ "rollout_disabled",+ {"enabled": False, "organization_ids": (), "self_driving_organization_percentage": 100.0},+ True,+ True,+ False,+ False,+ ),+ (+ "rollout_denied",+ {+ "organization_ids": (),+ "self_driving_organization_percentage": 100.0,+ "deny_organization_ids": ("own",),+ },+ True,+ True,+ False,+ False,+ ),+ (+ "rollout_team_skipped",+ {"organization_ids": (), "self_driving_organization_percentage": 100.0, "skip_team_ids": ("own",)},+ True,+ True,+ False,+ False,+ ),+ (+ "rollout_not_approved",+ {"organization_ids": (), "self_driving_organization_percentage": 100.0},+ False,+ True,+ False,+ False,+ ),])- def test_read_and_generation_checks_enroll_the_same_teams(- self, _name: str, overrides: dict[str, Any], approved: bool, expected: bool+ def test_read_and_generation_checks(+ self,+ _name: str,+ overrides: dict[str, Any],+ approved: bool,+ has_source: bool,+ readable: bool,+ generated: bool,) -> None:self.organization.is_ai_data_processing_approved = approvedself.organization.save()if overrides.get("skip_team_ids") == ("own",):overrides = {**overrides, "skip_team_ids": (self.team.id,)}+ if overrides.get("deny_organization_ids") == ("own",):+ overrides = {**overrides, "deny_organization_ids": (str(self.organization.id).upper(),)}+ if has_source:+ SignalSourceConfig.objects.create(+ team=self.team, source_product="error_tracking", source_type="issue_created", enabled=True+ )+ sourceless = Team.objects.create(organization=self.organization, name="No source")config = dataclasses.replace(self._config(), **overrides)team = Team.objects.get(id=self.team.id)- assert is_team_enrolled_for_read(config, team) is expected- assert is_team_enrolled_for_generation(config, team) is expected+ assert is_team_enrolled_for_read(config, team) is readable+ assert is_team_enrolled_for_generation(config, team) is generated+ assert (self.team.id in enrolled_team_ids(config)) is generated+ if config.self_driving_organization_percentage and not config.organization_ids:+ assert sourceless.id not in enrolled_team_ids(config)++ def test_a_pair_is_not_updated_when_the_team_leaves_the_enrollment_before_dispatch(self) -> None:+ self._changes(self.user, 3)+ assert self._select() == [(self.team.id, self.user.id)]+ denied = self._config(deny_organization_ids=(str(self.organization.id),))++ with (+ patch.object(tick, "read_config", return_value=denied),+ patch("products.signals.backend.activity_summary.logic.gateway_client") as gateway,+ ):+ result = run_pair(+ ActivitySummaryPairInput(+ team_id=self.team.id,+ user_id=self.user.id,+ min_units=3,+ min_update_interval_hours=24,+ emit_embeddings=True,+ capture_events=True,+ )+ )++ assert (result.status, result.called_model) == ("skipped_not_enrolled", False)+ gateway.assert_not_called()+ assert not UserActivitySummary.objects.for_team(self.team.id).exists()def test_daily_usage_counts_model_calls_and_prices_a_missing_cost_at_the_bound(self) -> None:priced, unpriced, skipped = (self._user(f"{name}@example.com") for name in ("priced", "unpriced", "skipped"))