Skip to content

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

feat(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.py
index 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.py
index 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 = False
organization_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 config
diff --git a/products/signals/backend/activity_summary/logic.py b/products/signals/backend/activity_summary/logic.py
index 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.py
index 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 th
import math
import uuid
+import hashlib
import datetime
from collections.abc import Callable
from 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) -> bool
return False
if 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 parsed
def _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_LAG
fed = 0
for 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: i
least `max_overdue_factor` staleness, for `paying_budget_share` of `limit`. The second pass ranks the
other 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.py
index 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 None
updates_left = max(0, config.max_pairs_per_day - usage.updates) if usage else 0
cost_left = max(0.0, config.max_cost_usd_per_day - usage.cost_usd) if usage else 0.0
tick_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 None
pairs = 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.py
index 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, Any
from django.conf import settings
from django.db import transaction
-from django.db.models import Q
+from django.db.models import Q, QuerySet
from django.utils import timezone
import 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 True
return _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.py
index 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, UserActivitySummaryQueueState
from products.signals.backend.test.test_activity_summary_render import FakeLLM
from 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 = approved
self.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"))