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): enforce standing reviewer exclusions in auto-assignment (#122443)

posthog[bot]1a00c105992b
diff --git a/.semgrep/rules/security/idor-team-scoped-models.yaml b/.semgrep/rules/security/idor-team-scoped-models.yaml
index b552e2367288..2ada6507f784 100644
--- a/.semgrep/rules/security/idor-team-scoped-models.yaml
+++ b/.semgrep/rules/security/idor-team-scoped-models.yaml
@@ -399,6 +399,8 @@ rules:
|SignalReportSuggestedReviewer
|SignalReportTask
|SignalReportTrackerIssue
+ |SignalReviewerExclusion
+ |SignalReviewerExclusionRevision
|SignalRepositoryAreaActivity
|SignalTeamConfig
|SignalSourceConfig
@@ -874,6 +876,8 @@ rules:
|SignalReportSuggestedReviewer
|SignalReportTask
|SignalReportTrackerIssue
+ |SignalReviewerExclusion
+ |SignalReviewerExclusionRevision
|SignalRepositoryAreaActivity
|SignalTeamConfig
|SignalSourceConfig
diff --git a/products/signals/backend/migrations/0203_reviewer_exclusion.py b/products/signals/backend/migrations/0203_reviewer_exclusion.py
new file mode 100644
index 000000000000..a9d1993db837
--- /dev/null
+++ b/products/signals/backend/migrations/0203_reviewer_exclusion.py
@@ -0,0 +1,193 @@
+# Generated by Django 5.2.18 on 2026-10-26 08:44
+
+import django.db.models.manager
+import django.db.models.deletion
+from django.conf import settings
+from django.db import migrations, models
+
+import posthog.uuidt
+
+
+class Migration(migrations.Migration):
+ dependencies = [
+ ("posthog", "1412_drop_retired_desktop_file_system_tables"),
+ ("signals", "0202_useractivitysummaryqueuestate_pending_score"),
+ migrations.swappable_dependency(settings.AUTH_USER_MODEL),
+ ]
+
+ operations = [
+ migrations.CreateModel(
+ name="SignalReviewerExclusion",
+ fields=[
+ (
+ "id",
+ models.UUIDField(
+ default=posthog.uuidt.uuid7,
+ editable=False,
+ primary_key=True,
+ serialize=False,
+ ),
+ ),
+ ("subject_user_uuid", models.UUIDField()),
+ (
+ "subject_github_login",
+ models.CharField(blank=True, max_length=100, null=True),
+ ),
+ (
+ "repository",
+ models.CharField(blank=True, default="", max_length=200),
+ ),
+ (
+ "path_prefix",
+ models.CharField(blank=True, default="", max_length=500),
+ ),
+ ("instruction", models.TextField()),
+ (
+ "status",
+ models.CharField(
+ choices=[("active", "Active"), ("revoked", "Revoked")],
+ default="active",
+ max_length=10,
+ ),
+ ),
+ ("revision", models.PositiveIntegerField(default=1)),
+ ("created_at", models.DateTimeField(auto_now_add=True)),
+ ("updated_at", models.DateTimeField(auto_now=True)),
+ (
+ "created_by",
+ models.ForeignKey(
+ blank=True,
+ db_constraint=False,
+ null=True,
+ on_delete=django.db.models.deletion.SET_NULL,
+ related_name="+",
+ to=settings.AUTH_USER_MODEL,
+ ),
+ ),
+ (
+ "team",
+ models.ForeignKey(
+ db_constraint=False,
+ on_delete=django.db.models.deletion.CASCADE,
+ related_name="+",
+ to="posthog.team",
+ ),
+ ),
+ ],
+ options={
+ "default_manager_name": "all_teams",
+ },
+ managers=[
+ ("all_teams", django.db.models.manager.Manager()),
+ ],
+ ),
+ migrations.CreateModel(
+ name="SignalReviewerExclusionRevision",
+ fields=[
+ (
+ "id",
+ models.UUIDField(
+ default=posthog.uuidt.uuid7,
+ editable=False,
+ primary_key=True,
+ serialize=False,
+ ),
+ ),
+ ("revision", models.PositiveIntegerField()),
+ (
+ "action",
+ models.CharField(
+ choices=[
+ ("created", "Created"),
+ ("revised", "Revised"),
+ ("revoked", "Revoked"),
+ ],
+ max_length=10,
+ ),
+ ),
+ ("subject_user_uuid", models.UUIDField()),
+ (
+ "subject_github_login",
+ models.CharField(blank=True, max_length=100, null=True),
+ ),
+ (
+ "repository",
+ models.CharField(blank=True, default="", max_length=200),
+ ),
+ (
+ "path_prefix",
+ models.CharField(blank=True, default="", max_length=500),
+ ),
+ ("instruction", models.TextField()),
+ (
+ "status",
+ models.CharField(
+ choices=[("active", "Active"), ("revoked", "Revoked")],
+ max_length=10,
+ ),
+ ),
+ ("created_at", models.DateTimeField(auto_now_add=True)),
+ (
+ "actor",
+ models.ForeignKey(
+ blank=True,
+ db_constraint=False,
+ null=True,
+ on_delete=django.db.models.deletion.SET_NULL,
+ related_name="+",
+ to=settings.AUTH_USER_MODEL,
+ ),
+ ),
+ (
+ "exclusion",
+ models.ForeignKey(
+ on_delete=django.db.models.deletion.CASCADE,
+ related_name="revisions",
+ to="signals.signalreviewerexclusion",
+ ),
+ ),
+ (
+ "team",
+ models.ForeignKey(
+ db_constraint=False,
+ on_delete=django.db.models.deletion.CASCADE,
+ related_name="+",
+ to="posthog.team",
+ ),
+ ),
+ ],
+ options={
+ "default_manager_name": "all_teams",
+ },
+ managers=[
+ ("all_teams", django.db.models.manager.Manager()),
+ ],
+ ),
+ migrations.AddIndex(
+ model_name="signalreviewerexclusion",
+ index=models.Index(fields=["team", "status"], name="signals_rev_excl_status_idx"),
+ ),
+ migrations.AddConstraint(
+ model_name="signalreviewerexclusion",
+ constraint=models.CheckConstraint(
+ condition=models.Q(
+ ("path_prefix", ""),
+ models.Q(("repository", ""), _negated=True),
+ _connector="OR",
+ ),
+ name="signals_rev_excl_path_needs_repo",
+ ),
+ ),
+ migrations.AddConstraint(
+ model_name="signalreviewerexclusion",
+ constraint=models.UniqueConstraint(
+ condition=models.Q(("status", "active")),
+ fields=("team", "subject_user_uuid", "repository", "path_prefix"),
+ name="signals_rev_excl_active_user_uniq",
+ ),
+ ),
+ migrations.AddConstraint(
+ model_name="signalreviewerexclusionrevision",
+ constraint=models.UniqueConstraint(fields=("exclusion", "revision"), name="signals_rev_excl_revision_uniq"),
+ ),
+ ]
diff --git a/products/signals/backend/migrations/max_migration.txt b/products/signals/backend/migrations/max_migration.txt
index cec63b7df899..9f784deae797 100644
--- a/products/signals/backend/migrations/max_migration.txt
+++ b/products/signals/backend/migrations/max_migration.txt
@@ -1 +1 @@
-0202_useractivitysummaryqueuestate_pending_score
+0203_reviewer_exclusion
diff --git a/products/signals/backend/models.py b/products/signals/backend/models.py
index de9ac2e7b2df..1ff816d539c6 100644
--- a/products/signals/backend/models.py
+++ b/products/signals/backend/models.py
@@ -2617,6 +2617,84 @@ class SignalReportMonitoringAttempt(UUIDModel):
]
+class SignalReviewerExclusion(TeamScopedRootMixin, UUIDModel):
+ """A standing instruction that keeps one person off automatic reviewer selection in one area.
+
+ The instruction applies to every automatic writer and does not expire. A person revokes it, and
+ every change appends a `SignalReviewerExclusionRevision`, so the row holds the current state and
+ the revisions hold its history.
+ """
+
+ class Status(models.TextChoices):
+ ACTIVE = "active", "Active"
+ REVOKED = "revoked", "Revoked"
+
+ all_teams = models.Manager() # noqa: DJ012
+
+ team = models.ForeignKey("posthog.Team", on_delete=models.CASCADE, db_constraint=False, related_name="+")
+ # The subject is always a PostHog user. The login is a snapshot for display and telemetry, never an identity.
+ subject_user_uuid = models.UUIDField()
+ subject_github_login = models.CharField(max_length=100, null=True, blank=True)
+ # An empty repository covers every repository. A path prefix narrows a repository to one subtree.
+ repository = models.CharField(max_length=200, blank=True, default="")
+ path_prefix = models.CharField(max_length=500, blank=True, default="")
+ instruction = models.TextField()
+ status = models.CharField(max_length=10, choices=Status, default=Status.ACTIVE)
+ revision = models.PositiveIntegerField(default=1)
+ created_by = models.ForeignKey(
+ "posthog.User", on_delete=models.SET_NULL, null=True, blank=True, db_constraint=False, related_name="+"
+ )
+ created_at = models.DateTimeField(auto_now_add=True)
+ updated_at = models.DateTimeField(auto_now=True)
+
+ class Meta:
+ default_manager_name = "all_teams"
+ indexes = [models.Index(fields=["team", "status"], name="signals_rev_excl_status_idx")]
+ constraints = [
+ models.CheckConstraint(
+ condition=models.Q(path_prefix="") | ~models.Q(repository=""),
+ name="signals_rev_excl_path_needs_repo",
+ ),
+ # One active instruction per person and area, so a retried create cannot leave a twin
+ # that stays active after the other is revoked.
+ models.UniqueConstraint(
+ fields=["team", "subject_user_uuid", "repository", "path_prefix"],
+ condition=models.Q(status="active"),
+ name="signals_rev_excl_active_user_uniq",
+ ),
+ ]
+
+
+class SignalReviewerExclusionRevision(TeamScopedRootMixin, UUIDModel):
+ """One append-only revision of a `SignalReviewerExclusion`, with the person who made it."""
+
+ class Action(models.TextChoices):
+ CREATED = "created", "Created"
+ REVISED = "revised", "Revised"
+ REVOKED = "revoked", "Revoked"
+
+ all_teams = models.Manager() # noqa: DJ012
+
+ team = models.ForeignKey("posthog.Team", on_delete=models.CASCADE, db_constraint=False, related_name="+")
+ exclusion = models.ForeignKey(SignalReviewerExclusion, on_delete=models.CASCADE, related_name="revisions")
+ revision = models.PositiveIntegerField()
+ action = models.CharField(max_length=10, choices=Action)
+ subject_user_uuid = models.UUIDField()
+ subject_github_login = models.CharField(max_length=100, null=True, blank=True)
+ repository = models.CharField(max_length=200, blank=True, default="")
+ path_prefix = models.CharField(max_length=500, blank=True, default="")
+ instruction = models.TextField()
+ status = models.CharField(max_length=10, choices=SignalReviewerExclusion.Status)
+ actor = models.ForeignKey(
+ "posthog.User", on_delete=models.SET_NULL, null=True, blank=True, db_constraint=False, related_name="+"
+ )
+ created_at = models.DateTimeField(auto_now_add=True)
+
+ class Meta:
+ default_manager_name = "all_teams"
+ constraints = [models.UniqueConstraint(fields=["exclusion", "revision"], name="signals_rev_excl_revision_uniq")]
+
+
# ── Signals scout (headless cross-source explorer) ──────────────────────────────
#
# Core tables backing the Signals scout:
diff --git a/products/signals/backend/report_generation/reviewer_telemetry.py b/products/signals/backend/report_generation/reviewer_telemetry.py
index 77c44c0ae8ef..8c928a19cd6c 100644
--- a/products/signals/backend/report_generation/reviewer_telemetry.py
+++ b/products/signals/backend/report_generation/reviewer_telemetry.py
@@ -7,6 +7,7 @@ import posthoganalytics
from posthog.dataclasses import frozen
from posthog.event_usage import groups
from posthog.models import Team
+from posthog.ph_client import ph_background_capture
from products.signals.backend.report_generation.resolve_reviewers import (
ReviewerResolutionDiagnostics,
@@ -188,3 +189,42 @@ def capture_suggested_reviewers_unresolved(
)
except Exception:
logger.exception("Failed to capture signals_suggested_reviewers_unresolved for report %s", report_id)
+
+
+ReviewerExclusionOutcome = Literal["suppressed", "pin_conflict", "unresolved"]
+
+
+def capture_reviewer_exclusion_applied(
+ *,
+ team_id: int,
+ report_id: str,
+ source: str,
+ events: list[tuple[ReviewerExclusionOutcome, list[str]]],
+) -> None:
+ """Emit one `signals_reviewer_exclusion_applied` per outcome when standing exclusions change a selection.
+
+ `suppressed` fires once per candidate an instruction removed. `pin_conflict` fires when a
+ report-specific pin keeps a person an instruction excludes, so a person must resolve it.
+ `unresolved` fires when the report or the instruction cannot tell whether it applies, so the
+ selection kept its current reviewers.
+
+ Best-effort: never raises, so analytics can't break a reviewer write.
+ """
+ try:
+ team = Team.objects.select_related("organization").get(id=team_id)
+ capture = ph_background_capture()
+ for outcome, exclusion_ids in events:
+ capture(
+ event="signals_reviewer_exclusion_applied",
+ distinct_id=str(team.uuid),
+ properties={
+ "team_id": team_id,
+ "report_id": report_id,
+ "outcome": outcome,
+ "source": source,
+ "exclusion_ids": exclusion_ids[:_MAX_LOGINS_PER_EVENT],
+ },
+ groups=groups(team.organization, team),
+ )
+ except Exception:
+ logger.exception("Failed to capture signals_reviewer_exclusion_applied for report %s", report_id)
diff --git a/products/signals/backend/reviewer_exclusions.py b/products/signals/backend/reviewer_exclusions.py
new file mode 100644
index 000000000000..b3ecc9fa0422
--- /dev/null
+++ b/products/signals/backend/reviewer_exclusions.py
@@ -0,0 +1,408 @@
+"""Standing instructions that keep a person off automatic reviewer selection in one area.
+
+A person who left an area records one instruction, and every automatic writer (research, scouts,
+custom agents) honors it through `ReviewerRules.prepare`. An instruction applies to a report when the
+report's selected repository matches and, for a path instruction, when one of its finding paths is
+under the prefix. When the report or the instruction cannot answer that question, the selection
+stays unresolved instead of guessing. Pull request assignment reads the same instructions, so an
+excluded person is neither assigned nor asked to review.
+
+The subject of an instruction is always a PostHog user. A candidate known only by a GitHub login
+resolves to the member who links that login now. A login that resolves to nobody cannot be excluded.
+"""
+
+from __future__ import annotations
+
+import json
+from uuid import UUID
+
+from django.db import IntegrityError, transaction
+from django.db.models import QuerySet
+
+import structlog
+
+from posthog.dataclasses import frozen
+
+from products.signals.backend.artefact_schemas import SuggestedReviewerEntry
+from products.signals.backend.models import (
+ SignalReportArtefact,
+ SignalReviewerExclusion,
+ SignalReviewerExclusionRevision,
+)
+from products.signals.backend.report_generation.resolve_reviewers import resolve_org_github_login_to_users
+
+logger = structlog.get_logger(__name__)
+
+
+class DuplicateExclusion(ValueError):
+ pass
+
+
+@frozen
+class StandingExclusion:
+ id: str
+ user_uuid: str
+ repository: str
+ path_prefix: str
+
+
+@frozen
+class Suppression:
+ exclusion_id: str
+ reviewer: SuggestedReviewerEntry
+
+
+@frozen
+class ExclusionReview:
+ kept: tuple[SuggestedReviewerEntry, ...]
+ suppressed: tuple[Suppression, ...]
+ unresolved: bool
+
+
+def _normalized_path(path: str) -> str:
+ return path.strip().removeprefix("./").strip("/")
+
+
+def _normalized_login(login: str | None) -> str | None:
+ return (login.strip().lower() or None) if login else None
+
+
+class StandingExclusions:
+ """The team's active instructions, read against one report's area evidence."""
+
+ def __init__(
+ self,
+ *,
+ team_id: int,
+ report_id: str,
+ repository_override: str | None,
+ versions: tuple[tuple[UUID, int], ...],
+ exclusions: tuple[StandingExclusion, ...],
+ repository: str | None,
+ paths: tuple[str, ...],
+ ) -> None:
+ self.team_id = team_id
+ self.report_id = report_id
+ self.repository_override = repository_override
+ self.versions = versions
+ self.exclusions = exclusions
+ self.repository = repository
+ self.paths = paths
+ # Each login resolves once per instance, however many candidate lists the caller checks.
+ self.user_uuid_by_login: dict[str, str | None] = {}
+
+ @classmethod
+ def load(cls, *, team_id: int, report_id: str, repository: str | None = None) -> StandingExclusions:
+ """Read the team's instructions against the report's area.
+
+ `repository` overrides the report's repository selection, for a caller that already knows
+ the repository the work landed in.
+ """
+ rows = list(
+ SignalReviewerExclusion.objects.for_team(team_id)
+ .filter(status=SignalReviewerExclusion.Status.ACTIVE)
+ .order_by("created_at", "id")
+ )
+ versions = tuple((row.id, row.revision) for row in rows)
+ exclusions = tuple(
+ StandingExclusion(
+ id=str(row.id),
+ user_uuid=str(row.subject_user_uuid),
+ repository=row.repository.strip().lower(),
+ path_prefix=_normalized_path(row.path_prefix),
+ )
+ for row in rows
+ )
+ if not exclusions:
+ return cls(
+ team_id=team_id,
+ report_id=report_id,
+ repository_override=repository,
+ versions=versions,
+ exclusions=(),
+ repository=None,
+ paths=(),
+ )
+ repository_override = repository
+ artefacts = SignalReportArtefact.objects.filter(team_id=team_id, report_id=report_id)
+ if repository is None:
+ selection = (
+ artefacts.filter(type=SignalReportArtefact.ArtefactType.REPO_SELECTION)
+ .order_by("-created_at", "-id")
+ .values_list("content", flat=True)
+ .first()
+ )
+ repository = cls._read_repository(selection)
+ else:
+ repository = repository.strip().lower() or None
+ paths: tuple[str, ...] = ()
+ # Finding paths decide only a path instruction for this report's repository, and the read runs
+ # under the report lock, so skip it for every other report.
+ if repository is not None and any(e.path_prefix and e.repository == repository for e in exclusions):
+ paths = cls._read_paths(artefacts.filter(type=SignalReportArtefact.ArtefactType.SIGNAL_FINDING))
+ return cls(
+ team_id=team_id,
+ report_id=report_id,
+ repository_override=repository_override,
+ versions=versions,
+ exclusions=exclusions,
+ repository=repository,
+ paths=paths,
+ )
+
+ def refreshed(self) -> StandingExclusions:
+ """These instructions when none changed since the load, otherwise a fresh load. One query when none changed."""
+ current = tuple(
+ SignalReviewerExclusion.objects.for_team(self.team_id)
+ .filter(status=SignalReviewerExclusion.Status.ACTIVE)
+ .order_by("created_at", "id")
+ .values_list("id", "revision")
+ )
+ if current == self.versions:
+ return self
+ fresh = StandingExclusions.load(
+ team_id=self.team_id, report_id=self.report_id, repository=self.repository_override
+ )
+ fresh.user_uuid_by_login = self.user_uuid_by_login
+ return fresh
+
+ def _member_uuids(self, logins: list[str]) -> list[str | None]:
+ """The member each login resolves to now, looked up once per login."""
+ normalized = [_normalized_login(login) for login in logins]
+ missing = {login for login in normalized if login is not None and login not in self.user_uuid_by_login}
+ if missing:
+ users = resolve_org_github_login_to_users(self.team_id, missing)
+ self.user_uuid_by_login.update(
+ {login: str(users[login].uuid) if login in users else None for login in missing}
+ )
+ return [self.user_uuid_by_login[login] if login is not None else None for login in normalized]
+
+ @staticmethod
+ def _read_repository(content: str | None) -> str | None:
+ try:
+ data = json.loads(content or "")
+ except ValueError:
+ return None
+ repository = data.get("repository") if isinstance(data, dict) else None
+ return repository.strip().lower() if isinstance(repository, str) and repository.strip() else None
+
+ @staticmethod
+ def _read_paths(findings: QuerySet[SignalReportArtefact]) -> tuple[str, ...]:
+ """The paths of each signal's current finding. Re-research supersedes a signal's older findings.
+
+ Content parses in Python because a JSONB cast fails the whole read on one malformed row.
+ """
+ current: dict[str | None, object] = {}
+ for content in (
+ findings.filter(content__startswith="{").order_by("-created_at", "-id").values_list("content", flat=True)
+ ):
+ try:
+ data = json.loads(content)
+ except ValueError:
+ logger.warning("signals.reviewer_exclusions.unreadable_finding")
+ continue
+ if not isinstance(data, dict):
+ continue
+ signal_id = data.get("signal_id")
+ current.setdefault(None if signal_id is None else str(signal_id), data.get("relevant_code_paths"))
+ paths: dict[str, None] = {}
+ for found in current.values():
+ for path in found if isinstance(found, list) else ():
+ if isinstance(path, str) and _normalized_path(path):
+ paths[_normalized_path(path)] = None
+ return tuple(paths)
+
+ def _applies(self, exclusion: StandingExclusion) -> bool | None:
+ """Whether the instruction covers this report, or None when the report cannot tell."""
+ if not exclusion.repository:
+ return True
+ if self.repository is None:
+ return None
+ if self.repository != exclusion.repository:
+ return False
+ if not exclusion.path_prefix:
+ return True
+ if not self.paths:
+ return None
+ return any(path == exclusion.path_prefix or path.startswith(f"{exclusion.path_prefix}/") for path in self.paths)
+
+ def _verdict(self, user_uuid: str | None) -> tuple[StandingExclusion | None, bool]:
+ """The first instruction that removes the member, and whether another one cannot tell."""
+ suppressing: StandingExclusion | None = None
+ unresolved = False
+ for exclusion in self.exclusions:
+ if user_uuid is None or exclusion.user_uuid != user_uuid:
+ continue
+ applies = self._applies(exclusion)
+ if applies is False:
+ continue
+ if applies is None:
+ unresolved = True
+ elif suppressing is None:
+ suppressing = exclusion
+ return suppressing, unresolved
+
+ def review(self, candidates: tuple[SuggestedReviewerEntry, ...]) -> ExclusionReview:
+ if not self.exclusions:
+ return ExclusionReview(kept=candidates, suppressed=(), unresolved=False)
+ member_uuids = [
+ candidate.user_uuid or member_uuid
+ for candidate, member_uuid in zip(
+ candidates,
+ self._member_uuids(
+ ["" if candidate.user_uuid else candidate.github_login or "" for candidate in candidates]
+ ),
+ )
+ ]
+ kept: list[SuggestedReviewerEntry] = []
+ suppressed: list[Suppression] = []
+ unresolved = False
+ for candidate, member_uuid in zip(candidates, member_uuids):
+ suppressing, uncertain = self._verdict(member_uuid)
+ unresolved = unresolved or uncertain
+ if suppressing is None:
+ kept.append(candidate)
+ else:
+ suppressed.append(Suppression(exclusion_id=suppressing.id, reviewer=candidate))
+ return ExclusionReview(kept=tuple(kept), suppressed=tuple(suppressed), unresolved=unresolved)
+
+ def allowed_logins(self, logins: list[str]) -> list[str]:
+ """The GitHub logins no instruction keeps off this area. A login nobody can decide on is left out."""
+ if not self.exclusions:
+ return list(logins)
+ allowed: list[str] = []
+ for login, member_uuid in zip(logins, self._member_uuids(logins)):
+ suppressing, unresolved = self._verdict(member_uuid)
+ if suppressing is None and not unresolved:
+ allowed.append(login)
+ return allowed
+
+
+def _record_revision(
+ exclusion: SignalReviewerExclusion, action: SignalReviewerExclusionRevision.Action, actor_id: int | None
+) -> None:
+ SignalReviewerExclusionRevision.objects.for_team(exclusion.team_id).create(
+ team_id=exclusion.team_id,
+ exclusion=exclusion,
+ revision=exclusion.revision,
+ action=action,
+ subject_user_uuid=exclusion.subject_user_uuid,
+ subject_github_login=exclusion.subject_github_login,
+ repository=exclusion.repository,
+ path_prefix=exclusion.path_prefix,
+ instruction=exclusion.instruction,
+ status=exclusion.status,
+ actor_id=actor_id,
+ )
+
+
+def _active_twins(
+ team_id: int, *, subject_user_uuid: UUID, repository: str, path_prefix: str
+) -> QuerySet[SignalReviewerExclusion]:
+ """Active instructions with the key of the partial unique index on the model."""
+ return SignalReviewerExclusion.objects.for_team(team_id).filter(
+ status=SignalReviewerExclusion.Status.ACTIVE,
+ subject_user_uuid=subject_user_uuid,
+ repository=repository,
+ path_prefix=path_prefix,
+ )
+
+
+def create_exclusion(
+ *,
+ team_id: int,
+ actor_id: int,
+ instruction: str,
+ subject_user_uuid: UUID,
+ subject_github_login: str | None = None,
+ repository: str = "",
+ path_prefix: str = "",
+) -> tuple[SignalReviewerExclusion, bool]:
+ """Create an instruction, or return the active one for the same member and area.
+
+ Returns the instruction and whether it was created, so a retried request does not leave a twin.
+ `subject_github_login` is a snapshot for display and plays no part in matching.
+ """
+ repository = repository.strip().lower()
+ path_prefix = _normalized_path(path_prefix)
+ active = _active_twins(team_id, subject_user_uuid=subject_user_uuid, repository=repository, path_prefix=path_prefix)
+ if existing := active.first():
+ return existing, False
+ try:
+ with transaction.atomic():
+ exclusion = SignalReviewerExclusion.objects.for_team(team_id).create(
+ team_id=team_id,
+ instruction=instruction,
+ created_by_id=actor_id,
+ subject_user_uuid=subject_user_uuid,
+ subject_github_login=_normalized_login(subject_github_login),
+ repository=repository,
+ path_prefix=path_prefix,
+ )
+ _record_revision(exclusion, SignalReviewerExclusionRevision.Action.CREATED, actor_id)
+ except IntegrityError:
+ # A concurrent create of the same instruction won the unique constraint.
+ if existing := active.first():
+ return existing, False
+ raise
+ return exclusion, True
+
+
+def revise_exclusion(
+ *,
+ team_id: int,
+ exclusion_id: UUID | str,
+ actor_id: int,
+ instruction: str | None = None,
+ repository: str | None = None,
+ path_prefix: str | None = None,
+) -> SignalReviewerExclusion:
+ """Apply the given changes as one new revision. A call that changes nothing records no revision."""
+ with transaction.atomic():
+ exclusion = (
+ SignalReviewerExclusion.objects.for_team(team_id)
+ .select_for_update()
+ .get(id=exclusion_id, status=SignalReviewerExclusion.Status.ACTIVE)
+ )
+ changes = {
+ field: value
+ for field, value in (
+ ("instruction", instruction),
+ ("repository", repository.strip().lower() if repository is not None else None),
+ ("path_prefix", _normalized_path(path_prefix) if path_prefix is not None else None),
+ )
+ if value is not None and value != getattr(exclusion, field)
+ }
+ if not changes:
+ return exclusion
+ for field, value in changes.items():
+ setattr(exclusion, field, value)
+ twin = _active_twins(
+ team_id,
+ subject_user_uuid=exclusion.subject_user_uuid,
+ repository=exclusion.repository,
+ path_prefix=exclusion.path_prefix,
+ ).exclude(id=exclusion.id)
+ if twin.exists():
+ raise DuplicateExclusion("An active exclusion already covers this person and area.")
+ exclusion.revision += 1
+ try:
+ with transaction.atomic():
+ exclusion.save()
+ except IntegrityError as e:
+ # A concurrent amend moved another row onto this area after the twin check.
+ raise DuplicateExclusion("An active exclusion already covers this person and area.") from e
+ _record_revision(exclusion, SignalReviewerExclusionRevision.Action.REVISED, actor_id)
+ return exclusion
+
+
+def revoke_exclusion(*, team_id: int, exclusion_id: UUID | str, actor_id: int) -> SignalReviewerExclusion:
+ with transaction.atomic():
+ exclusion = SignalReviewerExclusion.objects.for_team(team_id).select_for_update().get(id=exclusion_id)
+ if exclusion.status == SignalReviewerExclusion.Status.REVOKED:
+ return exclusion
+ exclusion.status = SignalReviewerExclusion.Status.REVOKED
+ exclusion.revision += 1
+ exclusion.save()
+ _record_revision(exclusion, SignalReviewerExclusionRevision.Action.REVOKED, actor_id)
+ return exclusion
diff --git a/products/signals/backend/reviewer_pr_assignment.py b/products/signals/backend/reviewer_pr_assignment.py
index 1cefded84be8..b45a6905bb35 100644
--- a/products/signals/backend/reviewer_pr_assignment.py
+++ b/products/signals/backend/reviewer_pr_assignment.py
@@ -7,6 +7,10 @@ Manual GitHub assignments and removals remain authoritative.
Other projects retain the legacy DRI and opt-in policies. Task execution permission is
separate from report and PR assignment. GitHub failures must not break report writes.
+
+Standing reviewer exclusions for the pull request's repository apply to every automatic candidate,
+including reviewer lists saved before the exclusion existed. The person who chose the work is
+still assigned, because a claim is a person's own decision.
"""
from __future__ import annotations
@@ -60,6 +64,7 @@ from products.signals.backend.report_generation.resolve_reviewers import (
normalized_github_logins_from_reviewer_payloads,
resolve_org_github_login_to_users,
)
+from products.signals.backend.reviewer_exclusions import StandingExclusions
from products.signals.backend.reviewer_rules import ReviewerRules, contains_reviewer
if TYPE_CHECKING:
@@ -357,6 +362,7 @@ def _request_reviews(
parsed: PullRequestRef,
pr: dict[str, Any],
reviewers: list[str],
+ standing: StandingExclusions,
) -> list[str]:
assignees = list(dict.fromkeys(str(login).lower() for login in (pr.get("assignees") or []) if login))
owner = assignees[0] if len(assignees) == 1 else None
@@ -366,6 +372,14 @@ def _request_reviews(
existing = {str(login).lower() for login in [pr.get("author"), *(pr.get("requested_reviewers") or [])] if login}
candidates = [owner] if owner else reviewers
wanted = [login for login in candidates if login.lower() not in existing]
+ if not wanted:
+ return []
+ # The sole assignee can be an earlier automatic owner who has since excluded themselves. The
+ # person who chose the work is still asked.
+ allowed = standing.allowed_logins(wanted)
+ if owner and not allowed and owner == (human_claimant_login(team_id=team_id, report_id=report_id) or "").lower():
+ allowed = wanted
+ wanted = allowed
if not wanted:
return []
@@ -739,7 +753,13 @@ def _report_assignee_logins(team: Team, snapshot: ReviewerSnapshot, *, require_o
def _assign_report_reviewers(
- github: GitHubIntegration, *, team_id: int, report_id: str, parsed: PullRequestRef, pr: dict[str, Any]
+ github: GitHubIntegration,
+ *,
+ team_id: int,
+ report_id: str,
+ parsed: PullRequestRef,
+ pr: dict[str, Any],
+ standing: StandingExclusions,
) -> list[str]:
assignments = PROwnerAssignmentService(
team_id=team_id,
@@ -772,7 +792,7 @@ def _assign_report_reviewers(
snapshot = ReviewerRules.read_for_report(team_id=team_id, report_id=report_id)
if snapshot.corrections.needs_review:
return []
- candidates = _report_assignee_logins(team, snapshot)
+ candidates = standing.allowed_logins(_report_assignee_logins(team, snapshot))
if len(candidates) < len(snapshot.reviewers):
log.info(
"signals.reviewer_pr_assignment.unavailable_accounts",
@@ -806,7 +826,11 @@ def _assign_report_reviewers(
if not current_application.allowed or current_application.previous != application.previous:
return []
current = ReviewerRules.read_for_report(team_id=team_id, report_id=report_id)
- if current.state != snapshot.state or _report_assignee_logins(team, current) != candidates:
+ # An instruction saved during the GitHub calls must still stop the assignment.
+ if (
+ current.state != snapshot.state
+ or standing.refreshed().allowed_logins(_report_assignee_logins(team, current)) != candidates
+ ):
return []
if not (
assignment_writer_enabled(team_id)
@@ -862,8 +886,13 @@ def assign_reviewers_to_pull_request(*, team_id: int, report_id: str, pr_url: st
if pr is None:
return []
+ standing = StandingExclusions.load(team_id=team_id, report_id=report_id, repository=parsed.repository)
+ logins = standing.allowed_logins(logins)
+ reviewers = standing.allowed_logins(reviewers)
if shared_assignment:
- assigned = _assign_report_reviewers(github, team_id=team_id, report_id=report_id, parsed=parsed, pr=pr)
+ assigned = _assign_report_reviewers(
+ github, team_id=team_id, report_id=report_id, parsed=parsed, pr=pr, standing=standing
+ )
elif dri_enabled:
assigned = _assign_one_dri(
github,
@@ -873,6 +902,7 @@ def assign_reviewers_to_pull_request(*, team_id: int, report_id: str, pr_url: st
pr=pr,
opted_in=set(logins),
reviewers=reviewers,
+ standing=standing,
)
else:
assigned = (
@@ -902,6 +932,7 @@ def assign_reviewers_to_pull_request(*, team_id: int, report_id: str, pr_url: st
if current_pr is None:
return assigned
pr = current_pr
+ # An instruction saved during the assignment calls must still stop the review request.
_request_reviews(
github,
team_id=team_id,
@@ -909,6 +940,7 @@ def assign_reviewers_to_pull_request(*, team_id: int, report_id: str, pr_url: st
parsed=parsed,
pr={**pr, "assignees": [*(pr.get("assignees") or []), *assigned]},
reviewers=reviewers,
+ standing=standing.refreshed(),
)
return assigned
@@ -922,6 +954,7 @@ def _assign_one_dri(
pr: dict[str, Any],
opted_in: set[str],
reviewers: list[str],
+ standing: StandingExclusions,
) -> list[str]:
"""Assign one DRI, replacing only a prior owner this worker recorded."""
assignments = PROwnerAssignmentService(
@@ -960,10 +993,12 @@ def _assign_one_dri(
reviewers=reviewers,
)
members = resolve_org_github_login_to_users(team_id, candidates)
+ allowed = set(standing.allowed_logins(candidates))
candidates = [
login
for login in candidates
- if not contains_reviewer(
+ if (login == claimant or login in allowed)
+ and not contains_reviewer(
snapshot.corrections.excluded,
SuggestedReviewerEntry(
github_login=login, user_uuid=str(members[login].uuid) if login in members else None
@@ -997,10 +1032,13 @@ def _assign_one_dri(
if not current_application.allowed or current_application.previous != application.previous:
return []
current = ReviewerRules.read_for_report(team_id=team_id, report_id=report_id)
+ # An instruction saved during the GitHub calls must still stop the assignment.
+ fresh = standing.refreshed()
if (
current.state != snapshot.state
or human_claimant_login(team_id=team_id, report_id=report_id) != claimant
- or ranked_reviewer_logins(team_id=team_id, report_id=report_id) != reviewers
+ or fresh.allowed_logins(ranked_reviewer_logins(team_id=team_id, report_id=report_id)) != reviewers
+ or not (owner.login == claimant or fresh.allowed_logins([owner.login]))
):
return []
return _apply_automatic_owners(
diff --git a/products/signals/backend/reviewer_rules.py b/products/signals/backend/reviewer_rules.py
index d2ff49b7892a..8ab430b6bc5c 100644
--- a/products/signals/backend/reviewer_rules.py
+++ b/products/signals/backend/reviewer_rules.py
@@ -3,6 +3,7 @@ from __future__ import annotations
import json
from uuid import UUID
+from django.db import transaction
from django.db.models import Q
from posthog.dataclasses import frozen
@@ -25,6 +26,11 @@ from products.signals.backend.report_generation.resolve_reviewers import (
get_org_member_github_logins_by_user_uuid,
resolve_org_github_login_to_users,
)
+from products.signals.backend.report_generation.reviewer_telemetry import (
+ ReviewerExclusionOutcome,
+ capture_reviewer_exclusion_applied,
+)
+from products.signals.backend.reviewer_exclusions import StandingExclusions
class ReviewerWriteError(ValueError):
@@ -254,6 +260,15 @@ class ReviewerRules:
unresolved_candidates=tuple(unresolved),
)
+ def _capture_exclusion_events(
+ self, events: list[tuple[ReviewerExclusionOutcome, list[str]]], *, source: str
+ ) -> None:
+ transaction.on_commit(
+ lambda: capture_reviewer_exclusion_applied(
+ team_id=self.team.id, report_id=self.report_id, source=source, events=events
+ )
+ )
+
def prepare(
self,
content: SuggestedReviewers,
@@ -264,6 +279,10 @@ class ReviewerRules:
) -> ReviewerUpdate:
"""Called by append_status while it holds the report lock."""
snapshot = self.read()
+ # Standing exclusions bind automatic writers only. A person's own edit or pin always wins.
+ # They load only on a path that can change the list, because the read runs under the report lock.
+ exclusions_bind = edit is None and attribution.kind != "user"
+ exclusion_events: list[tuple[ReviewerExclusionOutcome, list[str]]] = []
if edit is not None and attribution.kind != "user":
raise ReviewerWriteError("Only a person can change reviewer corrections.")
repairing = snapshot.invalid_reviewers
@@ -336,12 +355,31 @@ class ReviewerRules:
if corrections.confirmed or corrections.needs_review or failed:
proposed = snapshot.reviewers
else:
+ standing = (
+ StandingExclusions.load(team_id=self.team.id, report_id=self.report_id) if exclusions_bind else None
+ )
validated = self._validate_members(proposed)
- if proposed and not validated.reviewers:
+ review = (
+ standing.review(
+ tuple(
+ entry for entry in validated.reviewers if not contains_reviewer(corrections.pinned, entry)
+ )
+ )
+ if standing
+ else None
+ )
+ if review and review.unresolved:
+ exclusion_events.append(("unresolved", []))
+ if (proposed and not validated.reviewers) or (review and review.unresolved):
proposed = snapshot.reviewers
else:
+ suppressed = tuple(item.reviewer for item in review.suppressed) if review else ()
+ if review:
+ exclusion_events.extend(("suppressed", [item.exclusion_id]) for item in review.suppressed)
proposed = tuple(
- entry for entry in validated.reviewers if not contains_reviewer(corrections.excluded, entry)
+ entry
+ for entry in validated.reviewers
+ if not contains_reviewer(corrections.excluded + suppressed, entry)
)
extra_pins = tuple(
entry
@@ -352,12 +390,45 @@ class ReviewerRules:
)
proposed += self._validate_members(extra_pins).reviewers if extra_pins else ()
members_validated = True
+ pin_review = (
+ standing.review(
+ tuple(entry for entry in proposed if contains_reviewer(corrections.pinned, entry))
+ )
+ if standing
+ else None
+ )
+ if pin_review and pin_review.unresolved:
+ exclusion_events = [("unresolved", [])]
+ proposed = snapshot.reviewers
+ members_validated = False
+ elif pin_review and pin_review.suppressed:
+ corrections = corrections.model_copy(update={"needs_review": True})
+ exclusion_events.append(("pin_conflict", [item.exclusion_id for item in pin_review.suppressed]))
elif (
proposal
and proposal.source == "research"
and (corrections.pinned or corrections.excluded or corrections.needs_review)
):
proposed = snapshot.reviewers
+ elif (
+ exclusions_bind
+ and not protected
+ and (standing := StandingExclusions.load(team_id=self.team.id, report_id=self.report_id)).exclusions
+ ):
+ # Writers without the protected flow store login-only entries, so match on resolved
+ # identities and keep each entry as it was written.
+ resolved = self._resolve_identities(self.team.id, proposed)
+ review = standing.review(resolved)
+ if review.unresolved:
+ exclusion_events.append(("unresolved", []))
+ proposed = snapshot.reviewers
+ else:
+ exclusion_events.extend(("suppressed", [item.exclusion_id]) for item in review.suppressed)
+ proposed = tuple(
+ entry for entry, match in zip(proposed, resolved) if contains_reviewer(review.kept, match)
+ )
+ if exclusion_events:
+ self._capture_exclusion_events(exclusion_events, source=proposal.source if proposal else attribution.kind)
if protected and not members_validated:
proposed = self._validate_members(proposed).reviewers
reviewers = SuggestedReviewers(root=list(proposed))
diff --git a/products/signals/backend/test/test_report_pr_assignment.py b/products/signals/backend/test/test_report_pr_assignment.py
index a18f6247fb46..c98827a8c7e5 100644
--- a/products/signals/backend/test/test_report_pr_assignment.py
+++ b/products/signals/backend/test/test_report_pr_assignment.py
@@ -17,6 +17,7 @@ from products.signals.backend.artefact_schemas import (
)
from products.signals.backend.models import SignalReport, SignalReportArtefact, SignalUserAutonomyConfig
from products.signals.backend.report_assignments import claim_report
+from products.signals.backend.reviewer_exclusions import create_exclusion
from products.signals.backend.reviewer_pr_assignment import assign_reviewers_to_pull_request
from products.signals.backend.test.test_reviewer_pr_assignment import (
_NOT_UNASSIGNED,
@@ -202,7 +203,8 @@ class TestReportPRAssignment:
assert github.is_assignable.call_count == (1 if assignable else 10)
@pytest.mark.parametrize(
- "change", ["reviewers", "identity", "access", "preference", "github", "delivery", "writer", "selection"]
+ "change",
+ ["reviewers", "identity", "access", "preference", "github", "exclusion", "delivery", "writer", "selection"],
)
def test_a_change_during_permission_checks_stops_assignment(self, org_and_team, change):
org, team = org_and_team
@@ -221,6 +223,10 @@ class TestReportPRAssignment:
SignalUserAutonomyConfig.objects.filter(user=selected).update(github_assign_on_pull_request=False)
elif change == "github":
github.assignee_state[:] = ["manual-owner"]
+ elif change == "exclusion":
+ create_exclusion(
+ team_id=team.id, actor_id=selected.id, instruction="Off.", subject_user_uuid=selected.uuid
+ )
return {"success": True, "assignable": True}
github.is_assignable.side_effect = check
@@ -235,6 +241,8 @@ class TestReportPRAssignment:
else:
assert self.assign(report, github) == []
github.add_pull_request_assignees.assert_not_called()
+ if change == "exclusion":
+ github.request_pull_request_reviews.assert_not_called()
@pytest.mark.parametrize("opted_in", [False, True])
def test_retry_uses_current_github_assignment_preference(
diff --git a/products/signals/backend/test/test_reviewer_pr_assignment.py b/products/signals/backend/test/test_reviewer_pr_assignment.py
index 1417d5f2f807..3feb1c8ba53a 100644
--- a/products/signals/backend/test/test_reviewer_pr_assignment.py
+++ b/products/signals/backend/test/test_reviewer_pr_assignment.py
@@ -25,6 +25,7 @@ from products.signals.backend.report_assignments import (
sync_task_pull_request_to_assignments,
update_assignments_for_pull_request,
)
+from products.signals.backend.reviewer_exclusions import create_exclusion
from products.signals.backend.reviewer_pr_assignment import (
assign_reviewers_to_pull_request,
opted_in_assignee_logins,
@@ -879,6 +880,55 @@ class TestDirectlyResponsibleIndividual:
assert self._assign(team, report, github) == []
+ @pytest.mark.django_db
+ @pytest.mark.parametrize(
+ ("login_snapshot", "repository", "expected_owner"),
+ [
+ (None, "PostHog/posthog", "bob"),
+ ("alice-before-rename", "posthog/posthog", "bob"),
+ ("bob", "posthog/posthog", "bob"),
+ (None, "PostHog/other", "alice"),
+ ],
+ ids=[
+ "user_in_this_repository",
+ "user_after_login_change",
+ "login_moved_to_another_member",
+ "another_repository",
+ ],
+ )
+ def test_standing_exclusions_keep_a_person_off_owner_and_review_candidates(
+ self, org_and_team: tuple[Organization, Team], login_snapshot: str | None, repository: str, expected_owner: str
+ ) -> None:
+ org, team = org_and_team
+ report, users = self._setup(org, team, ["alice", "bob"])
+ create_exclusion(
+ team_id=team.id,
+ actor_id=users["alice"].id,
+ instruction="I moved off this repository.",
+ subject_user_uuid=users["alice"].uuid,
+ subject_github_login=login_snapshot,
+ repository=repository,
+ )
+ github = self._github(existing_assignees=[], assignable=None)
+
+ assert self._assign(team, report, github) == [[expected_owner]]
+ assert [call.args[2] for call in github.request_pull_request_reviews.call_args_list] == [[expected_owner]]
+
+ @pytest.mark.django_db
+ def test_an_excluded_earlier_owner_is_not_asked_to_review(self, org_and_team: tuple[Organization, Team]) -> None:
+ org, team = org_and_team
+ report, users = self._setup(org, team, ["alice"])
+ github = self._github(existing_assignees=[], assignable=None)
+ assert self._assign(team, report, github) == [["alice"]]
+ github.request_pull_request_reviews.reset_mock()
+ create_exclusion(
+ team_id=team.id, actor_id=users["alice"].id, instruction="Off.", subject_user_uuid=users["alice"].uuid
+ )
+
+ self._assign(team, report, github)
+
+ github.request_pull_request_reviews.assert_not_called()
+
@pytest.mark.django_db
@pytest.mark.parametrize("source", ["claimant", "reviewer-uuid", "reviewer-login"])
@pytest.mark.parametrize("unavailable", ["inactive", "project"])
@@ -903,14 +953,29 @@ class TestDirectlyResponsibleIndividual:
@pytest.mark.django_db
@pytest.mark.parametrize(
- "change", ["assigned", "unassigned", "closed", "history-unavailable", "report", "claimant"]
+ "change",
+ [
+ "assigned",
+ "unassigned",
+ "closed",
+ "history-unavailable",
+ "report",
+ "claimant",
+ "exclusion",
+ "owner-exclusion",
+ ],
)
def test_changes_during_github_checks_stop_dri_assignment(
- self, org_and_team: tuple[Organization, Team], change: str
+ self, org_and_team: tuple[Organization, Team], ownership: MagicMock, change: str
) -> None:
org, team = org_and_team
report, users = self._setup(org, team, ["alice"])
github = self._github(existing_assignees=[], assignable=None)
+ if change == "owner-exclusion":
+ ownership.return_value = PathOwnership(
+ team_by_path={"posthog/api/a.py": "team-x"}, registry={}, resolved=True
+ )
+ github.list_team_members.return_value = {"success": True, "logins": ["carol"]}
def check(_repo: str, _login: str) -> dict[str, bool]:
if change == "assigned":
@@ -926,6 +991,11 @@ class TestDirectlyResponsibleIndividual:
SignalReportArtefact.objects.create(team=team, report=report, type="suggested_reviewers", content="[]")
elif change == "claimant":
self._claim(team, report, users, kind="user", login="bob")
+ elif change in ("exclusion", "owner-exclusion"):
+ subject = users["alice" if change == "exclusion" else "carol"]
+ create_exclusion(
+ team_id=team.id, actor_id=subject.id, instruction="Off.", subject_user_uuid=subject.uuid
+ )
return {"success": True, "assignable": True}
github.is_assignable.side_effect = check
diff --git a/products/signals/backend/test/test_reviewer_rules.py b/products/signals/backend/test/test_reviewer_rules.py
index c17d75c0a8ee..4a72519018dc 100644
--- a/products/signals/backend/test/test_reviewer_rules.py
+++ b/products/signals/backend/test/test_reviewer_rules.py
@@ -4,13 +4,15 @@ from uuid import UUID
from posthog.test.base import BaseTest
from unittest.mock import patch
+from django.db import connection
from django.test import SimpleTestCase
+from django.test.utils import CaptureQueriesContext
from django.utils import timezone
from parameterized import parameterized
from social_django.models import UserSocialAuth
-from posthog.models import OrganizationMembership, User
+from posthog.models import OrganizationMembership, Team, User
from posthog.models.activity_logging.activity_log import ActivityLog
from products.signals.backend.artefact_attribution import ArtefactAttribution
@@ -25,11 +27,23 @@ from products.signals.backend.artefact_schemas import (
WorkClaim,
)
from products.signals.backend.assignment_flags import assignment_side_effects_allowed, assignment_writer_enabled
-from products.signals.backend.models import SignalReport, SignalReportArtefact
+from products.signals.backend.models import (
+ SignalReport,
+ SignalReportArtefact,
+ SignalReviewerExclusion,
+ SignalReviewerExclusionRevision,
+)
from products.signals.backend.report_generation.resolve_reviewers import (
get_org_member_github_logins_by_user_uuid,
resolve_org_github_login_to_users,
)
+from products.signals.backend.reviewer_exclusions import (
+ DuplicateExclusion,
+ StandingExclusions,
+ create_exclusion,
+ revise_exclusion,
+ revoke_exclusion,
+)
from products.signals.backend.reviewer_rules import ReviewerRules, ReviewerWriteError, StaleReviewerProposal
from products.signals.backend.suggested_reviewer_index import report_ids_naming_reviewers, sync_suggested_reviewer_index
@@ -447,6 +461,297 @@ class TestReviewerRules(BaseTest):
) == [{"report_id": self.report.id}]
+class TestStandingExclusions(BaseTest):
+ def setUp(self) -> None:
+ super().setUp()
+ self.enabled = True
+ self.flag = patch(
+ "products.signals.backend.reviewer_rules.assignment_writer_enabled", side_effect=lambda _: self.enabled
+ )
+ self.flag.start()
+ self.addCleanup(self.flag.stop)
+ effects = patch("products.signals.backend.reviewer_rules.assignment_side_effects_enabled", return_value=False)
+ effects.start()
+ self.addCleanup(effects.stop)
+ capture = patch("products.signals.backend.reviewer_rules.capture_reviewer_exclusion_applied")
+ self.capture = capture.start()
+ self.addCleanup(capture.stop)
+ self.report = SignalReport.objects.create(team=self.team, status="ready", title="A report")
+ self.rules = ReviewerRules(team=self.team, report_id=str(self.report.id))
+ self.member = User.objects.create(email="[email protected]")
+ OrganizationMembership.objects.create(user=self.member, organization=self.organization)
+ self.me = SuggestedReviewerEntry(user_uuid=str(self.user.uuid))
+ self.other = SuggestedReviewerEntry(user_uuid=str(self.member.uuid))
+ SignalReportArtefact.objects.create(
+ team=self.team, report=self.report, type="repo_selection", content=json.dumps({"repository": "Org/App"})
+ )
+ SignalReportArtefact.objects.create(
+ team=self.team,
+ report=self.report,
+ type="signal_finding",
+ content=json.dumps({"signal_id": "s1", "relevant_code_paths": ["/src/billing/charge.py"]}),
+ )
+
+ def exclude(self, **area: str) -> str:
+ exclusion, _ = create_exclusion(
+ team_id=self.team.id,
+ actor_id=self.member.id,
+ instruction="I moved off this area.",
+ subject_user_uuid=self.member.uuid,
+ **area,
+ )
+ return str(exclusion.id)
+
+ def write(self, *reviewers: SuggestedReviewerEntry, source: str = "research") -> None:
+ with self.captureOnCommitCallbacks(execute=True):
+ SignalReportArtefact.append_status(
+ team_id=self.team.id,
+ report_id=str(self.report.id),
+ content=SuggestedReviewers(root=list(reviewers)),
+ attribution=ArtefactAttribution.system(),
+ reviewer_proposal=ReviewerProposal(expected_state=self.rules.read().state, source=source),
+ )
+
+ @parameterized.expand(
+ [
+ ("research_any_repo", "research", {}, True, True, None, False),
+ ("scout_same_repo", "scout", {"repository": "org/app"}, True, True, None, False),
+ (
+ "custom_agent_path",
+ "custom_agent",
+ {"repository": "org/app", "path_prefix": "src/billing"},
+ True,
+ True,
+ None,
+ False,
+ ),
+ ("other_repo", "research", {"repository": "org/other"}, True, False, None, False),
+ ("other_path", "scout", {"repository": "org/app", "path_prefix": "src/bill"}, True, False, None, False),
+ (
+ "superseded_finding_path",
+ "research",
+ {"repository": "org/app", "path_prefix": "src/billing"},
+ True,
+ False,
+ ["src/search/query.py"],
+ False,
+ ),
+ ("writer_disabled", "research", {"repository": "org/app"}, False, True, None, False),
+ ("writer_disabled_login_only", "custom_agent", {}, False, True, None, True),
+ ]
+ )
+ def test_matching_instruction_suppresses_the_subject_for_every_writer(
+ self,
+ _name: str,
+ source: str,
+ area: dict[str, str],
+ enabled: bool,
+ suppressed: bool,
+ rewritten_paths: list[str] | None,
+ by_login: bool,
+ ) -> None:
+ self.enabled = enabled
+ if rewritten_paths is not None:
+ SignalReportArtefact.objects.create(
+ team=self.team,
+ report=self.report,
+ type="signal_finding",
+ content=json.dumps({"signal_id": "s1", "relevant_code_paths": rewritten_paths}),
+ )
+ other = self.other
+ if by_login:
+ UserSocialAuth.objects.create(user=self.member, provider="github", uid="1", extra_data={"login": "member"})
+ other = SuggestedReviewerEntry(github_login="member")
+ exclusion_id = self.exclude(**area)
+ self.write(self.me, other, source=source)
+ assert [entry.user_uuid or entry.github_login for entry in self.rules.read().reviewers] == (
+ [self.me.user_uuid] if suppressed else [self.me.user_uuid, other.user_uuid or other.github_login]
+ )
+ assert [call.kwargs for call in self.capture.call_args_list] == (
+ [
+ {
+ "team_id": self.team.id,
+ "report_id": str(self.report.id),
+ "source": source,
+ "events": [("suppressed", [exclusion_id])],
+ }
+ ]
+ if suppressed
+ else []
+ )
+
+ def test_unreadable_findings_do_not_block_a_path_instruction(self) -> None:
+ for content in ["{not json", '{"signal_id": "s2", "relevant_code_paths": ["src/search/\\u0000.py"]}']:
+ SignalReportArtefact.objects.create(
+ team=self.team, report=self.report, type="signal_finding", content=content
+ )
+ self.exclude(repository="org/app", path_prefix="src/billing")
+ self.write(self.me, self.other)
+ assert [entry.user_uuid for entry in self.rules.read().reviewers] == [self.me.user_uuid]
+
+ def test_login_only_writer_skips_identity_resolution_without_instructions(self) -> None:
+ self.enabled = False
+ UserSocialAuth.objects.create(user=self.member, provider="github", uid="1", extra_data={"login": "member"})
+ with self.assertNumQueries(25):
+ self.write(self.me, SuggestedReviewerEntry(github_login="member"), source="custom_agent")
+
+ def test_revoked_instruction_stops_suppressing_and_keeps_history(self) -> None:
+ exclusion_id = self.exclude()
+ revise_exclusion(team_id=self.team.id, exclusion_id=exclusion_id, actor_id=self.user.id, repository="org/app")
+ revise_exclusion(team_id=self.team.id, exclusion_id=exclusion_id, actor_id=self.user.id, repository=" Org/App ")
+ revoke_exclusion(team_id=self.team.id, exclusion_id=exclusion_id, actor_id=self.user.id)
+ self.write(self.other)
+ assert [entry.user_uuid for entry in self.rules.read().reviewers] == [self.other.user_uuid]
+ assert list(
+ SignalReviewerExclusionRevision.objects.for_team(self.team.id)
+ .filter(exclusion_id=exclusion_id)
+ .order_by("revision")
+ .values_list("revision", "action", "repository", "status", "actor_id")
+ ) == [
+ (1, "created", "", "active", self.member.id),
+ (2, "revised", "org/app", "active", self.user.id),
+ (3, "revoked", "org/app", "revoked", self.user.id),
+ ]
+
+ @parameterized.expand(
+ [
+ ("no_repository", {"repository": "org/app"}, "repo_selection", True),
+ ("no_repository_writer_disabled", {"repository": "org/app"}, "repo_selection", False),
+ ("no_paths", {"repository": "org/app", "path_prefix": "src"}, "signal_finding", True),
+ ("no_paths_writer_disabled", {"repository": "org/app", "path_prefix": "src"}, "signal_finding", False),
+ ]
+ )
+ def test_missing_area_state_keeps_the_current_selection(
+ self, _name: str, area: dict[str, str], missing: str, enabled: bool
+ ) -> None:
+ self.enabled = enabled
+ self.write(self.me)
+ SignalReportArtefact.objects.filter(report=self.report, type=missing).delete()
+ self.exclude(**area)
+ self.write(self.other)
+ assert [entry.user_uuid for entry in self.rules.read().reviewers] == [self.me.user_uuid]
+ assert [event for call in self.capture.call_args_list for event in call.kwargs["events"]] == [
+ ("unresolved", [])
+ ]
+
+ @parameterized.expand([("covered", True), ("repository_unknown", False)])
+ def test_report_pin_wins_and_needs_a_person(self, _name: str, area_known: bool) -> None:
+ SignalReportArtefact.append_status(
+ team_id=self.team.id,
+ report_id=str(self.report.id),
+ content=SuggestedReviewers(root=[self.other]),
+ attribution=ArtefactAttribution.from_user(self.user.id),
+ reviewer_edit=ReviewerEdit(action="add"),
+ )
+ if not area_known:
+ SignalReportArtefact.objects.filter(report=self.report, type="repo_selection").delete()
+ exclusion_id = self.exclude(repository="org/app")
+ self.write(self.me, self.other)
+ snapshot = self.rules.read()
+ assert [entry.user_uuid for entry in snapshot.reviewers] == (
+ [self.me.user_uuid, self.other.user_uuid] if area_known else [self.other.user_uuid]
+ )
+ assert snapshot.corrections.needs_review is area_known
+ assert [event for call in self.capture.call_args_list for event in call.kwargs["events"]] == [
+ ("pin_conflict", [exclusion_id]) if area_known else ("unresolved", [])
+ ]
+
+ def test_confirmed_list_is_kept_without_reading_instructions(self) -> None:
+ self.write(self.me)
+ SignalReportArtefact.append_status(
+ team_id=self.team.id,
+ report_id=str(self.report.id),
+ content=SuggestedReviewers(root=[]),
+ attribution=ArtefactAttribution.from_user(self.user.id),
+ reviewer_edit=ReviewerEdit(action="confirm", expected_state=self.rules.read().state),
+ )
+ self.exclude()
+ with CaptureQueriesContext(connection) as queries:
+ self.write(self.other)
+ assert [entry.user_uuid for entry in self.rules.read().reviewers] == [self.me.user_uuid]
+ assert not [query for query in queries.captured_queries if "signalreviewerexclusion" in query["sql"]]
+
+ def test_finding_paths_are_read_only_for_a_path_instruction_in_the_report_repository(self) -> None:
+ self.exclude(repository="org/other", path_prefix="src/billing")
+ self.exclude(repository="org/app")
+ with CaptureQueriesContext(connection) as queries:
+ StandingExclusions.load(team_id=self.team.id, report_id=str(self.report.id))
+ assert not [query for query in queries.captured_queries if "signal_finding" in query["sql"]]
+
+ def test_create_returns_the_active_twin_and_revise_rejects_one(self) -> None:
+ first = self.exclude(repository="org/app")
+ assert self.exclude(repository=" Org/App ") == first
+ after_github_connect, created = create_exclusion(
+ team_id=self.team.id,
+ actor_id=self.member.id,
+ instruction="I moved off this area.",
+ subject_user_uuid=self.member.uuid,
+ subject_github_login="Reviewer",
+ repository="org/app",
+ )
+ assert (str(after_github_connect.id), created) == (first, False)
+ second = self.exclude(repository="org/other")
+ with self.assertRaises(DuplicateExclusion):
+ revise_exclusion(team_id=self.team.id, exclusion_id=second, actor_id=self.user.id, repository="org/app")
+ # A concurrent amend can pass the twin check and still lose the unique index.
+ with (
+ patch(
+ "products.signals.backend.reviewer_exclusions._active_twins",
+ return_value=SignalReviewerExclusion.objects.none(),
+ ),
+ self.assertRaises(DuplicateExclusion),
+ ):
+ revise_exclusion(team_id=self.team.id, exclusion_id=second, actor_id=self.user.id, repository="org/app")
+ assert SignalReviewerExclusion.objects.for_team(self.team.id).get(id=second).repository == "org/other"
+
+ def test_a_moved_login_does_not_make_another_member_a_twin(self) -> None:
+ theirs, _ = create_exclusion(
+ team_id=self.team.id,
+ actor_id=self.member.id,
+ instruction="Off.",
+ subject_user_uuid=self.member.uuid,
+ subject_github_login="shared-login",
+ )
+ mine, created = create_exclusion(
+ team_id=self.team.id,
+ actor_id=self.user.id,
+ instruction="Off.",
+ subject_user_uuid=self.user.uuid,
+ subject_github_login="shared-login",
+ )
+ assert created
+ assert {theirs.subject_user_uuid, mine.subject_user_uuid} == {self.member.uuid, self.user.uuid}
+
+ def test_each_login_resolves_once_per_load(self) -> None:
+ UserSocialAuth.objects.create(user=self.member, provider="github", uid="1", extra_data={"login": "member"})
+ self.exclude()
+ standing = StandingExclusions.load(team_id=self.team.id, report_id=str(self.report.id))
+ with patch(
+ "products.signals.backend.reviewer_exclusions.resolve_org_github_login_to_users",
+ wraps=resolve_org_github_login_to_users,
+ ) as resolve:
+ assert standing.allowed_logins(["member", "someone"]) == ["someone"]
+ assert standing.allowed_logins(["Member"]) == []
+ assert resolve.call_count == 1
+
+ def test_active_twin_is_scoped_to_one_team(self) -> None:
+ self.exclude(repository="org/app")
+ self.exclude(repository="org/other")
+ other_team = Team.objects.create(organization=self.organization)
+ same_area, created = create_exclusion(
+ team_id=other_team.id,
+ actor_id=self.member.id,
+ instruction="I moved off this area.",
+ subject_user_uuid=self.member.uuid,
+ repository="org/app",
+ )
+ assert created
+ revised = revise_exclusion(
+ team_id=other_team.id, exclusion_id=same_area.id, actor_id=self.member.id, repository="org/other"
+ )
+ assert (revised.team_id, revised.repository) == (other_team.id, "org/other")
+
+
class TestAssignmentReleaseControls(SimpleTestCase):
@parameterized.expand([(None, False), (False, False), ("enabled", False), (True, True)])
def test_writer_requires_explicit_enablement(self, value: object, enabled: bool) -> None: