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.

fix(signals): stop closed source records from forking resolved reports (#126419)

Dylan Martin60d784ab5e37
diff --git a/products/signals/backend/emission/pipeline.py b/products/signals/backend/emission/pipeline.py
index 9ded74f98ebe..44d06a12b9f2 100644
--- a/products/signals/backend/emission/pipeline.py
+++ b/products/signals/backend/emission/pipeline.py
@@ -31,7 +31,9 @@ from products.signals.backend.emission.registry import (
from products.signals.backend.emission.steering import SourceSteering, apply_steering, steering_from_config
from products.signals.backend.facade.api import emit_signal
from products.signals.backend.llm_spend import generate_with_spend
-from products.signals.backend.models import SignalEmissionRecord
+from products.signals.backend.models import SignalEmissionRecord, SignalReport
+from products.signals.backend.recurrence import reports_fork_recurrence
+from products.signals.backend.report_merge import signal_target_reports
from products.signals.backend.spend import complete_signal_pipeline, finalized_signal_ids, signal_id_for
from products.signals.backend.spend_billing import system_source_exempt
from products.signals.backend.system_one_decision import run_model_decision
@@ -628,6 +630,16 @@ async def _emit_signals(
return succeeded
+def _reports_closed_to_source_state(team_id: int, report_ids: set[str]) -> set[str]:
+ """The matched reports whose signals would fork a recurrence, after following merges and recurrences."""
+ if not report_ids:
+ return set()
+ reports = list(SignalReport.objects.filter(team_id=team_id, id__in=report_ids))
+ targets = signal_target_reports(team_id=team_id, reports=reports)
+ closed_targets = reports_fork_recurrence(team_id=team_id, reports=list(targets.values()))
+ return {report_id for report_id, target in targets.items() if str(target.id) in closed_targets}
+
+
async def run_signal_pipeline(
team: Team,
config: SignalSourceTableConfig,
@@ -712,8 +724,21 @@ async def run_signal_pipeline(
else output
for output in outputs
]
+ # A source state change such as a closed issue only refreshes an open report. On a resolved
+ # report it usually means the fix landed, so it must not file a recurrence.
+ closed_report_ids = await database_sync_to_async(_reports_closed_to_source_state, thread_sensitive=False)(
+ team.id,
+ {
+ output.source_match_report_id
+ for output in outputs
+ if output.existing_source_only and output.source_match_report_id is not None
+ },
+ )
+ kept_outputs = []
for output in outputs:
- if output.existing_source_only and output.source_match_report_id is None:
+ if not output.existing_source_only:
+ kept_outputs.append(output)
+ elif output.source_match_report_id is None:
capture_pipeline_stage(
"signal_data_source_filtered",
team,
@@ -721,9 +746,17 @@ async def run_signal_pipeline(
output,
{"filter_reason": "source_state_without_report"},
)
- outputs = [
- output for output in outputs if not output.existing_source_only or output.source_match_report_id is not None
- ]
+ elif output.source_match_report_id in closed_report_ids:
+ capture_pipeline_stage(
+ "signal_data_source_filtered",
+ team,
+ organization,
+ output,
+ {"filter_reason": "source_state_on_closed_report"},
+ )
+ else:
+ kept_outputs.append(output)
+ outputs = kept_outputs
if config.summarization_prompt is not None and config.description_summarization_threshold_chars is not None:
threshold = config.description_summarization_threshold_chars
diff --git a/products/signals/backend/emission/tests/test_emit_signals.py b/products/signals/backend/emission/tests/test_emit_signals.py
index 046f0d262009..c4b1f5239bc2 100644
--- a/products/signals/backend/emission/tests/test_emit_signals.py
+++ b/products/signals/backend/emission/tests/test_emit_signals.py
@@ -8,7 +8,9 @@ from typing import Any
import pytest
from unittest.mock import AsyncMock, MagicMock, patch
+from django.db import connection
from django.test import override_settings
+from django.test.utils import CaptureQueriesContext
from django.utils import timezone
import temporalio.worker
@@ -21,6 +23,7 @@ from posthog.hogql import ast
from posthog.sync import database_sync_to_async
from products.ml_inference.backend.facade.contracts import DecisionResult, NoulAnswer
+from products.signals.backend.artefact_schemas import Dismissal, ReportLink
from products.signals.backend.emission._prompts import ISSUE_ACTIONABILITY_PROMPT
from products.signals.backend.emission.emit_signals import (
EmitDataImportSignalsWorkflow,
@@ -32,6 +35,7 @@ from products.signals.backend.emission.pipeline import (
LLM_MAX_ATTEMPTS,
TEMPORAL_PAYLOAD_MAX_BYTES,
_emit_signals,
+ _reports_closed_to_source_state,
_summarize_description,
build_emitter_outputs,
check_actionability,
@@ -40,7 +44,8 @@ from products.signals.backend.emission.pipeline import (
summarize_long_descriptions,
)
from products.signals.backend.emission.registry import SignalEmitterOutput, SignalSourceTableConfig
-from products.signals.backend.models import SignalEmissionRecord, SignalSpend
+from products.signals.backend.enums import ReportLinkKind
+from products.signals.backend.models import SignalEmissionRecord, SignalReport, SignalReportArtefact, SignalSpend
from products.signals.backend.spend import signal_id_for
PIPELINE_MODULE_PATH = "products.signals.backend.emission.pipeline"
@@ -923,18 +928,79 @@ class TestEmitSignals:
@pytest.mark.django_db(transaction=True)
class TestExistingSourceOnlyOutputs:
+ def test_closed_report_lookup_batches_reports_links_and_dismissals(self, team):
+ resolved = SignalReport.objects.create(team=team, status=SignalReport.Status.RESOLVED)
+ fixed_dismissal = SignalReport.objects.create(team=team, status=SignalReport.Status.SUPPRESSED)
+ SignalReportArtefact.objects.create(
+ team=team,
+ report=fixed_dismissal,
+ type=SignalReportArtefact.ArtefactType.DISMISSAL,
+ content=Dismissal(state="suppressed", reason="already_fixed").model_dump_json(),
+ )
+
+ merge_survivor = SignalReport.objects.create(team=team, status=SignalReport.Status.READY)
+ merged_source = SignalReport.objects.create(team=team, status=SignalReport.Status.SUPPRESSED)
+ SignalReportArtefact.objects.create(
+ team=team,
+ report=merged_source,
+ type=SignalReportArtefact.ArtefactType.DISMISSAL,
+ content=Dismissal(state="suppressed", reason="merged").model_dump_json(),
+ )
+ SignalReportArtefact.objects.create(
+ team=team,
+ report=merged_source,
+ type=SignalReportArtefact.ArtefactType.REPORT_LINK,
+ content=ReportLink(kind=ReportLinkKind.DUPLICATE_OF, report_id=str(merge_survivor.id)).model_dump_json(),
+ link_target_id=merge_survivor.id,
+ )
+
+ recurrence_parent = SignalReport.objects.create(team=team, status=SignalReport.Status.RESOLVED)
+ recurrence = SignalReport.objects.create(team=team, status=SignalReport.Status.READY)
+ SignalReportArtefact.objects.create(
+ team=team,
+ report=recurrence,
+ type=SignalReportArtefact.ArtefactType.REPORT_LINK,
+ content=ReportLink(
+ kind=ReportLinkKind.RECURRENCE_OF, report_id=str(recurrence_parent.id)
+ ).model_dump_json(),
+ link_target_id=recurrence_parent.id,
+ )
+
+ closed = _reports_closed_to_source_state(
+ team.id,
+ {str(resolved.id), str(fixed_dismissal.id), str(merged_source.id), str(recurrence_parent.id)},
+ )
+
+ assert closed == {str(resolved.id), str(fixed_dismissal.id)}
+
+ direct_reports = SignalReport.objects.bulk_create(
+ [SignalReport(team=team, status=SignalReport.Status.RESOLVED) for _ in range(20)]
+ )
+ with CaptureQueriesContext(connection) as one_report_queries:
+ _reports_closed_to_source_state(team.id, {str(direct_reports[0].id)})
+ with CaptureQueriesContext(connection) as many_report_queries:
+ _reports_closed_to_source_state(team.id, {str(report.id) for report in direct_reports})
+
+ assert len(many_report_queries) == len(one_report_queries)
+
@pytest.mark.asyncio
async def test_terminal_source_only_emits_when_it_already_has_a_report(self, team):
config = _make_config(sync_with_source=True, actionability_prompt="Actionable? {description}")
+ open_report = await SignalReport.objects.acreate(team=team, status=SignalReport.Status.READY)
+ resolved_report = await SignalReport.objects.acreate(team=team, status=SignalReport.Status.RESOLVED)
records: list[dict[str, Any]] = [
{"id": "open", "state": "open"},
{"id": "known-closed", "state": "closed", "existing_source_only": True},
{"id": "new-closed", "state": "closed", "existing_source_only": True},
+ {"id": "resolved-closed", "state": "closed", "existing_source_only": True},
]
with (
patch(
f"{PIPELINE_MODULE_PATH}.fetch_source_signal_matches",
- return_value={"known-closed": [MagicMock(signal_id="previous-signal", report_id="existing-report")]},
+ return_value={
+ "known-closed": [MagicMock(signal_id="previous-signal", report_id=str(open_report.id))],
+ "resolved-closed": [MagicMock(signal_id="fixed-signal", report_id=str(resolved_report.id))],
+ },
),
patch(f"{PIPELINE_MODULE_PATH}.emit_signal", new_callable=AsyncMock) as emit,
patch(
@@ -951,19 +1017,22 @@ class TestExistingSourceOnlyOutputs:
assert {call.kwargs["source_id"] for call in emit.await_args_list} == {"open", "known-closed"}
known_call = next(call for call in emit.await_args_list if call.kwargs["source_id"] == "known-closed")
assert known_call.kwargs["source_match_signal_id"] == "previous-signal"
- assert known_call.kwargs["source_match_report_id"] == "existing-report"
+ assert known_call.kwargs["source_match_report_id"] == str(open_report.id)
assert filter_actionable.await_args is not None
assert [output.source_id for output in filter_actionable.await_args.kwargs["outputs"]] == ["open"]
filtered = [call for call in capture.call_args_list if call.kwargs["event"] == "signal_data_source_filtered"]
- assert [call.kwargs["properties"]["source_id"] for call in filtered] == ["new-closed"]
- assert filtered[0].kwargs["properties"]["filter_reason"] == "source_state_without_report"
+ assert [
+ (call.kwargs["properties"]["source_id"], call.kwargs["properties"]["filter_reason"]) for call in filtered
+ ] == [
+ ("new-closed", "source_state_without_report"),
+ ("resolved-closed", "source_state_on_closed_report"),
+ ]
@pytest.mark.django_db(transaction=True)
class TestPipelineStageTelemetry:
@pytest.mark.asyncio
async def test_captures_each_stage_per_signal(self, team):
-
short_description = "short actionable bug"
long_description = "x" * 500
non_actionable_description = "billing question, not actionable"
diff --git a/products/signals/backend/recurrence.py b/products/signals/backend/recurrence.py
index ffd04f123ba9..a71e4951b2dc 100644
--- a/products/signals/backend/recurrence.py
+++ b/products/signals/backend/recurrence.py
@@ -5,6 +5,7 @@ A wrong-repo dismissal leaves the issue unresolved. Both need a fresh report for
signals, but only fixed verdicts supply prior-fix context to research.
"""
+from collections.abc import Collection
from datetime import datetime
from pydantic import ValidationError
@@ -54,6 +55,61 @@ def recurrence_dismissal_at(report: SignalReport) -> datetime | None:
return _dismissal_at(report, FIXED_DISMISSAL_REASONS | {DISMISSAL_REASON_WRONG_REPO})
+def dismissal_reasons_by_report(*, team_id: int, report_ids: Collection[str]) -> dict[str, list[str | None]]:
+ """Dismissal reasons for several reports in newest-first order, including malformed rows as None."""
+ if not report_ids:
+ return {}
+ rows = (
+ SignalReportArtefact.objects.using("default")
+ .filter(
+ report_id__in=report_ids,
+ team_id=team_id,
+ type=SignalReportArtefact.ArtefactType.DISMISSAL,
+ )
+ .order_by("report_id", "-created_at")
+ .values_list("report_id", "content")
+ )
+ reasons_by_report: dict[str, list[str | None]] = {}
+ for report_id, content in rows:
+ try:
+ reason = Dismissal.model_validate_json(content).reason
+ except ValidationError:
+ reason = None
+ reasons_by_report.setdefault(str(report_id), []).append(reason)
+ return reasons_by_report
+
+
+def reports_fork_recurrence(*, team_id: int, reports: Collection[SignalReport]) -> set[str]:
+ """The reports that fork new evidence, with dismissal state loaded once for the batch."""
+ from products.signals.backend.report_content_gates import (
+ team_report_monitoring_enabled, # noqa: PLC0415 — keeps the flag client off module startup
+ )
+
+ monitoring_enabled = not any(report.status == SignalReport.Status.MONITORING for report in reports) or (
+ team_report_monitoring_enabled(team_id)
+ )
+ terminal_ids = {
+ str(report.id)
+ for report in reports
+ if report.status in {SignalReport.Status.RESOLVED, SignalReport.Status.CLOSED}
+ or (report.status == SignalReport.Status.MONITORING and not monitoring_enabled)
+ }
+ suppressed_ids = {str(report.id) for report in reports if report.status == SignalReport.Status.SUPPRESSED}
+ reasons_by_report = dismissal_reasons_by_report(team_id=team_id, report_ids=suppressed_ids)
+ return terminal_ids | {
+ report_id
+ for report_id in suppressed_ids
+ if reasons_by_report.get(report_id, [None])[0] in (FIXED_DISMISSAL_REASONS | {DISMISSAL_REASON_WRONG_REPO})
+ }
+
+
+def forks_recurrence(report: SignalReport) -> bool:
+ """Whether a new signal on `report` starts a fresh recurrence report instead of joining it."""
+ if report.effective_status in {SignalReport.Status.RESOLVED, SignalReport.Status.CLOSED}:
+ return True
+ return report.status == SignalReport.Status.SUPPRESSED and recurrence_dismissal_at(report) is not None
+
+
def recurrence_rejects_repository(*, team_id: int, report_id: str, repository: str) -> bool:
for edge in outgoing_links(team_id=team_id, report_id=report_id, kinds=(ReportLinkKind.RECURRENCE_OF,)):
latest = _latest_dismissal(team_id=team_id, report_id=edge.target_id)
diff --git a/products/signals/backend/report_merge.py b/products/signals/backend/report_merge.py
index 6d294a6ccd70..73dbf4c78b9a 100644
--- a/products/signals/backend/report_merge.py
+++ b/products/signals/backend/report_merge.py
@@ -43,9 +43,10 @@ from products.signals.backend.models import (
SignalReportGithubComment,
SignalScoutRun,
)
-from products.signals.backend.recurrence import latest_recurrence_report
+from products.signals.backend.recurrence import dismissal_reasons_by_report, latest_recurrence_report
from products.signals.backend.report_tags import set_report_tags, union_report_tags
from products.signals.backend.signal_metadata import REASSIGN_SIGNAL_ROW_CAP
+from products.signals.backend.typed_report_links import incoming_links_by_report, outgoing_links_by_report
logger = structlog.get_logger(__name__)
@@ -208,6 +209,105 @@ def signal_target_report(report: SignalReport, *, lock: bool = False) -> SignalR
return report
+def signal_target_reports(*, team_id: int, reports: list[SignalReport]) -> dict[str, SignalReport]:
+ """`signal_target_report` for a batch, loading each graph level in a fixed number of queries."""
+ targets = {str(report.id): report for report in reports}
+ outer_visited: dict[str, set[UUID]] = {report_id: set() for report_id in targets}
+ active = set(targets)
+
+ for _ in range(SignalReportArtefact.MAX_REPORT_LINK_GRAPH_NODES):
+ if not active:
+ break
+ starting_targets = {report_id: targets[report_id] for report_id in active}
+ for report_id, report in starting_targets.items():
+ outer_visited[report_id].add(report.id)
+
+ recurrence_cursors = {report_id: targets[report_id] for report_id in active}
+ recurrence_visited = {report_id: {targets[report_id].id} for report_id in active}
+ recurrence_active = set(active)
+ for _ in range(SignalReportArtefact.MAX_REPORT_LINK_GRAPH_LEVELS):
+ if not recurrence_active:
+ break
+ cursor_ids = {str(recurrence_cursors[report_id].id) for report_id in recurrence_active}
+ recurrence_edges = incoming_links_by_report(
+ team_id=team_id,
+ report_ids=cursor_ids,
+ kinds=(ReportLinkKind.RECURRENCE_OF,),
+ include_deleted_sources=True,
+ )
+ recurrence_ids = {edge.source_id for edges in recurrence_edges.values() for edge in edges}
+ recurrence_reports = {
+ str(report.id): report for report in SignalReport.objects.filter(team_id=team_id, id__in=recurrence_ids)
+ }
+ next_active: set[str] = set()
+ for report_id in recurrence_active:
+ cursor_id = str(recurrence_cursors[report_id].id)
+ candidates = [
+ recurrence_reports[edge.source_id]
+ for edge in recurrence_edges.get(cursor_id, [])
+ if edge.source_id in recurrence_reports
+ ]
+ if not candidates:
+ continue
+ successor = max(candidates, key=lambda report: report.created_at)
+ if successor.id in recurrence_visited[report_id]:
+ continue
+ recurrence_visited[report_id].add(successor.id)
+ recurrence_cursors[report_id] = successor
+ if successor.status != SignalReport.Status.DELETED:
+ targets[report_id] = successor
+ next_active.add(report_id)
+ recurrence_active = next_active
+
+ merge_active = set(active)
+ merge_visited = {report_id: {targets[report_id].id} for report_id in active}
+ for _ in range(SignalReportArtefact.MAX_REPORT_LINK_GRAPH_LEVELS):
+ suppressed_ids = {
+ str(targets[report_id].id)
+ for report_id in merge_active
+ if targets[report_id].status == SignalReport.Status.SUPPRESSED
+ }
+ reasons_by_report = dismissal_reasons_by_report(team_id=team_id, report_ids=suppressed_ids)
+ merged_ids = {
+ report_id
+ for report_id in suppressed_ids
+ if MERGE_DISMISSAL_REASON in reasons_by_report.get(report_id, [])
+ }
+ merge_edges = outgoing_links_by_report(
+ team_id=team_id,
+ report_ids=merged_ids,
+ kinds=(ReportLinkKind.DUPLICATE_OF,),
+ )
+ survivor_ids = {edges[-1].target_id for edges in merge_edges.values() if edges}
+ survivors = {
+ str(report.id): report
+ for report in SignalReport.objects.filter(team_id=team_id, id__in=survivor_ids).exclude(
+ status=SignalReport.Status.DELETED
+ )
+ }
+ next_active = set()
+ for report_id in merge_active:
+ current_id = str(targets[report_id].id)
+ edges = merge_edges.get(current_id, [])
+ survivor = survivors.get(edges[-1].target_id) if edges else None
+ if survivor is None or survivor.id in merge_visited[report_id]:
+ continue
+ targets[report_id] = survivor
+ merge_visited[report_id].add(survivor.id)
+ next_active.add(report_id)
+ if not next_active:
+ break
+ merge_active = next_active
+
+ active = {
+ report_id
+ for report_id in active
+ if targets[report_id].id != starting_targets[report_id].id
+ and targets[report_id].id not in outer_visited[report_id]
+ }
+ return targets
+
+
def _release_source_claim(source: SignalReport, attribution: ArtefactAttribution) -> bool:
"""End any active claim on the source, so no claim is left stranded on an archived report.
diff --git a/products/signals/backend/temporal/grouping.py b/products/signals/backend/temporal/grouping.py
index c10a4bd0e56e..7d3a6aadf0c1 100644
--- a/products/signals/backend/temporal/grouping.py
+++ b/products/signals/backend/temporal/grouping.py
@@ -39,7 +39,7 @@ from products.signals.backend.enums import ReportLinkKind, ReportLinkWritePath,
from products.signals.backend.models import SignalEmissionRecord, SignalReport, SignalReportArtefact
from products.signals.backend.quota import capture_signal_report_quota_paused, self_driving_quota_gate
from products.signals.backend.receivers import _is_safety_suppressed
-from products.signals.backend.recurrence import recurrence_dismissal_at
+from products.signals.backend.recurrence import forks_recurrence
from products.signals.backend.report_merge import signal_target_report
from products.signals.backend.report_monitoring_signals import current_research_attempt
from products.signals.backend.signal_metadata import EMBEDDING_MODEL
@@ -930,13 +930,7 @@ async def assign_and_emit_signal_activity(input: AssignAndEmitSignalInput) -> As
# Wrong-repo feedback rejects the repository choice rather than the issue, so new
# evidence needs fresh research, just as it does after a fixed verdict.
report = signal_target_report(report, lock=True)
- dismissed_for_recurrence_at = (
- recurrence_dismissal_at(report) if report.status == SignalReport.Status.SUPPRESSED else None
- )
- if (
- report.effective_status in {SignalReport.Status.RESOLVED, SignalReport.Status.CLOSED}
- or dismissed_for_recurrence_at is not None
- ):
+ if forks_recurrence(report):
parent_report = report
inherit_content = not _is_safety_suppressed(str(parent_report.id), input.team_id)
report = SignalReport.objects.create(
diff --git a/products/signals/backend/test/test_report_links.py b/products/signals/backend/test/test_report_links.py
index e1f4138fe900..1d526299dc3d 100644
--- a/products/signals/backend/test/test_report_links.py
+++ b/products/signals/backend/test/test_report_links.py
@@ -13,8 +13,10 @@ from products.signals.backend.typed_report_links import (
duplicate_root,
has_open_or_merged_pull_request,
incoming_links,
+ incoming_links_by_report,
linked_reports,
outgoing_links,
+ outgoing_links_by_report,
)
@@ -67,6 +69,25 @@ class TestReportLinkReaders(BaseTest):
assert len(incoming_links(team_id=self.team.id, report_id=str(target.id).upper())) == 1
+ @parameterized.expand([("outgoing",), ("incoming",)])
+ def test_the_row_budget_applies_to_each_report_in_a_batch(self, direction: str):
+ busy, quiet, other = self._report("busy"), self._report("quiet"), self._report("other")
+ if direction == "outgoing":
+ self._link(busy, other, ReportLinkKind.DEPENDS_ON)
+ self._link(busy, quiet, ReportLinkKind.PART_OF)
+ self._link(quiet, other, ReportLinkKind.RECURRENCE_OF)
+ else:
+ self._link(other, busy, ReportLinkKind.DEPENDS_ON)
+ self._link(quiet, busy, ReportLinkKind.PART_OF)
+ self._link(busy, quiet, ReportLinkKind.RECURRENCE_OF)
+ read = outgoing_links_by_report if direction == "outgoing" else incoming_links_by_report
+
+ with patch.object(SignalReportArtefact, "MAX_REPORT_LINK_GRAPH_ROWS", 1):
+ edges = read(team_id=self.team.id, report_ids=[str(busy.id), str(quiet.id)])
+
+ assert len(edges[str(busy.id)]) == 1
+ assert [edge.kind for edge in edges[str(quiet.id)]] == [ReportLinkKind.RECURRENCE_OF]
+
@parameterized.expand([("outgoing",), ("incoming",)])
def test_a_row_that_no_longer_parses_names_no_edge(self, direction: str):
source, target = self._report("source"), self._report("target")
diff --git a/products/signals/backend/typed_report_links.py b/products/signals/backend/typed_report_links.py
index 06ea7516d7ff..fb4c62078728 100644
--- a/products/signals/backend/typed_report_links.py
+++ b/products/signals/backend/typed_report_links.py
@@ -14,6 +14,9 @@ parsing. Nothing mirrors the row onto the target, because the direction is the p
import uuid
from collections.abc import Collection
+from django.db.models import F, QuerySet, Window
+from django.db.models.functions import RowNumber
+
import structlog
import posthoganalytics
from pydantic import ValidationError
@@ -68,6 +71,28 @@ def _edges_from_rows(
return edges
+def _rows_within_budget_per_report(
+ candidates: QuerySet[SignalReportArtefact], *, partition_field: str
+) -> QuerySet[SignalReportArtefact, tuple[uuid.UUID, str]]:
+ """`(report_id, content)` rows, oldest first, with the graph row budget applied to each report.
+
+ One budget shared by the whole batch would let a report with many links hide the links of every
+ report after it, so a batch read could give a different answer than the single-report read.
+ """
+ return (
+ candidates.annotate(
+ _report_rank=Window(
+ expression=RowNumber(),
+ partition_by=[F(partition_field)],
+ order_by=[F("created_at").asc(), F("id").asc()],
+ )
+ )
+ .filter(_report_rank__lte=SignalReportArtefact.MAX_REPORT_LINK_GRAPH_ROWS)
+ .order_by("created_at", "id")
+ .values_list("report_id", "content")
+ )
+
+
def outgoing_links(
*, team_id: int, report_id: str | uuid.UUID, kinds: Collection[ReportLinkKind] | None = None
) -> list[ReportEdge]:
@@ -91,14 +116,12 @@ def outgoing_links_by_report(
source_ids = [source_id for source_id in map(_canonical_report_id, report_ids) if source_id is not None]
if not source_ids:
return {}
- rows = (
- SignalReportArtefact.objects.using("default")
- .filter(team_id=team_id, report_id__in=source_ids, type=SignalReportArtefact.ArtefactType.REPORT_LINK)
- .order_by("created_at", "id")
- .values_list("report_id", "content")[: SignalReportArtefact.MAX_REPORT_LINK_GRAPH_ROWS]
+ candidates = SignalReportArtefact.objects.using("default").filter(
+ team_id=team_id, report_id__in=source_ids, type=SignalReportArtefact.ArtefactType.REPORT_LINK
)
+ rows = list(_rows_within_budget_per_report(candidates, partition_field="report_id"))
edges_by_report: dict[str, list[ReportEdge]] = {}
- for edge in _edges_from_rows(list(rows), kinds=kinds):
+ for edge in _edges_from_rows(rows, kinds=kinds):
edges_by_report.setdefault(edge.source_id, []).append(edge)
return edges_by_report
@@ -135,6 +158,32 @@ def incoming_links(
return [edge for edge in _edges_from_rows(rows, kinds=kinds) if edge.target_id == target_id]
+def incoming_links_by_report(
+ *,
+ team_id: int,
+ report_ids: Collection[str],
+ kinds: Collection[ReportLinkKind] | None = None,
+ include_deleted_sources: bool = False,
+) -> dict[str, list[ReportEdge]]:
+ """`incoming_links` for several reports in one query, keyed by target report id."""
+ target_ids = {target_id for target_id in map(_canonical_report_id, report_ids) if target_id is not None}
+ if not target_ids:
+ return {}
+ candidates = SignalReportArtefact.objects.using("default").filter(
+ team_id=team_id,
+ type=SignalReportArtefact.ArtefactType.REPORT_LINK,
+ link_target_id__in=target_ids,
+ )
+ if not include_deleted_sources:
+ candidates = candidates.exclude(report__status=SignalReport.Status.DELETED)
+ rows = list(_rows_within_budget_per_report(candidates, partition_field="link_target_id"))
+ edges_by_report: dict[str, list[ReportEdge]] = {}
+ for edge in _edges_from_rows(rows, kinds=kinds):
+ if edge.target_id in target_ids:
+ edges_by_report.setdefault(edge.target_id, []).append(edge)
+ return edges_by_report
+
+
def duplicate_chain(*, team_id: int, report_id: str | uuid.UUID) -> list[str]:
"""The reports this one duplicates, nearest first, ending at the one that duplicates nothing.