feat(autofix): Attempt to fetch logs (#92111)

Attempts to collect logs around an event and send them to Seer. Wrapped
with a try-except in case it breaks.

Author: roaga

src/sentry/seer/autofix.py

@@ -19,8 +19,10 @@
 from sentry.models.group import Group
 from sentry.models.project import Project
 from sentry.profiles.utils import get_from_profiling_service
+from sentry.search.events.types import EventsResponse, SnubaParams
 from sentry.seer.seer_setup import get_seer_org_acknowledgement
 from sentry.seer.signed_seer_api import sign_with_seer_secret
+from sentry.snuba import ourlogs
 from sentry.snuba.dataset import Dataset
 from sentry.snuba.referrer import Referrer
 from sentry.tasks.autofix import check_autofix_status
@@ -33,6 +35,110 @@
 TIMEOUT_SECONDS = 60 * 30  # 30 minutes
 
 
+def _get_logs_for_event(event: Event | GroupEvent, project: Project) -> list[dict] | None:
+    trace_id = event.trace_id
+    if not trace_id:
+        return None
+
+    projects_qs = Project.objects.filter(
+        organization=project.organization, status=ObjectStatus.ACTIVE
+    )
+    projects = list(projects_qs)
+    project_id_to_slug = dict(projects_qs.values_list("id", "slug"))
+    start = event.datetime - timedelta(days=1)
+    end = event.datetime + timedelta(days=1)
+
+    snuba_params = SnubaParams(
+        start=start,
+        end=end,
+        projects=projects,
+        organization=project.organization,
+    )
+
+    results: EventsResponse = ourlogs.query(
+        selected_columns=[
+            "project.id",
+            "timestamp",
+            "message",
+            "severity",
+            "code.file.path",
+            "code.function.name",
+        ],
+        query=f"trace_id:{trace_id}",
+        snuba_params=snuba_params,
+        orderby=["-timestamp"],
+        offset=0,
+        limit=100,
+        referrer=Referrer.API_GROUP_AI_AUTOFIX,
+    )
+    data = results["data"]
+
+    # Convert log timestamps to datetime and sort by timestamp ascending (oldest first)
+    for log in data:
+        ts = log.get("timestamp")
+        if ts:
+            try:
+                log["_parsed_ts"] = datetime.fromisoformat(ts)
+            except Exception:
+                log["_parsed_ts"] = None
+        else:
+            log["_parsed_ts"] = None
+
+    # Sort logs by timestamp ascending (oldest first)
+    data.sort(key=lambda x: x.get("_parsed_ts") or datetime.min)
+
+    # Find the index of the log closest to the event timestamp (faster with min and enumerate)
+    closest_idx = 0
+    if data:
+        valid_logs = [(i, log) for i, log in enumerate(data) if log.get("_parsed_ts") is not None]
+        if valid_logs:
+            closest_idx, _ = min(
+                (
+                    (i, abs((log["_parsed_ts"] - event.datetime).total_seconds()))
+                    for i, log in valid_logs
+                ),
+                key=lambda x: x[1],
+                default=(0, None),
+            )
+
+    # Select up to 80 logs before and up to 20 logs after (including the closest)
+    start_idx = max(0, closest_idx - 80)
+    end_idx = min(len(data), closest_idx + 21)
+    window = data[start_idx:end_idx]
+
+    # Merge and count consecutive logs with identical message and severity
+    merged_logs = []
+    prev_log = None
+    count = 0
+    for log in window:
+        project_id = log.get("project.id")
+        log["project_slug"] = project_id_to_slug.get(project_id) if project_id else None
+        log["code_file_path"] = log.get("code.file.path")
+        log["code_function_name"] = log.get("code.function.name")
+        log.pop("code.file.path", None)
+        log.pop("code.function.name", None)
+        log.pop("_parsed_ts", None)
+        log.pop("project.id", None)
+
+        msg = log.get("message")
+        sev = log.get("severity")
+        if prev_log and msg == prev_log["message"] and sev == prev_log["severity"]:
+            count += 1
+        else:
+            if prev_log:
+                if count > 1:
+                    prev_log["consecutive_count"] = count
+                merged_logs.append(prev_log)
+            prev_log = log.copy()
+            count = 1
+    if prev_log:
+        if count > 1:
+            prev_log["consecutive_count"] = count
+        merged_logs.append(prev_log)
+
+    return merged_logs
+
+
 def build_spans_tree(spans_data: list[dict]) -> list[dict]:
     """
     Builds a hierarchical tree structure from a flat list of spans.
@@ -676,6 +782,7 @@ def _call_autofix(
     serialized_event: dict[str, Any],
     profile: dict[str, Any] | None,
     trace_tree: dict[str, Any] | None,
+    logs: list[dict] | None,
     instruction: str | None = None,
     timeout_secs: int = TIMEOUT_SECONDS,
     pr_to_comment_on_url: str | None = None,
@@ -696,6 +803,7 @@ def _call_autofix(
             },
             "profile": profile,
             "trace_tree": trace_tree,
+            "logs": logs,
             "instruction": instruction,
             "timeout_secs": timeout_secs,
             "last_updated": datetime.now().isoformat(),
@@ -791,6 +899,13 @@ def trigger_autofix(
         logger.exception("Failed to get profile from trace tree")
         profile = None
 
+    # get logs for this event
+    try:
+        logs = _get_logs_for_event(event, group.project) if event else None
+    except Exception:
+        logger.exception("Failed to get logs for event")
+        logs = None
+
     try:
         run_id = _call_autofix(
             user=user,
@@ -799,6 +914,7 @@ def trigger_autofix(
             serialized_event=serialized_event,
             profile=profile,
             trace_tree=trace_tree,
+            logs=logs,
             instruction=instruction,
             timeout_secs=TIMEOUT_SECONDS,
             pr_to_comment_on_url=pr_to_comment_on_url,

tests/sentry/seer/test_autofix.py

@@ -9,6 +9,7 @@
     TIMEOUT_SECONDS,
     _call_autofix,
     _convert_profile_to_execution_tree,
+    _get_logs_for_event,
     _get_profile_from_trace_tree,
     _get_trace_tree_for_event,
     _respond_with_error,
@@ -1335,6 +1336,7 @@ def test_call_autofix(self, mock_sign, mock_post):
         serialized_event = {"event_id": "test-event"}
         profile = {"profile_data": "test"}
         trace_tree = {"trace_data": "test"}
+        logs = [{"message": "test-log"}]
         instruction = "Test instruction"
 
         # Call the function with keyword arguments
@@ -1345,6 +1347,7 @@ def test_call_autofix(self, mock_sign, mock_post):
             serialized_event=serialized_event,
             profile=profile,
             trace_tree=trace_tree,
+            logs=logs,
             instruction=instruction,
             timeout_secs=TIMEOUT_SECONDS,
             pr_to_comment_on_url="https://github.com/getsentry/sentry/pull/123",
@@ -1587,3 +1590,68 @@ def test_build_spans_tree_duration_sorting(self):
         assert root["children"][0]["span_id"] == "slow-child"
         assert root["children"][1]["span_id"] == "medium-child"
         assert root["children"][2]["span_id"] == "fast-child"
+
+
+class TestGetLogsForEvent(TestCase):
+    def setUp(self):
+        super().setUp()
+        self.organization = self.create_organization()
+        self.project = self.create_project(organization=self.organization)
+        self.trace_id = "1234567890abcdef1234567890abcdef"
+        self.now = before_now(minutes=0)
+
+    @patch("sentry.snuba.ourlogs.query")
+    def test_merging_consecutive_logs(self, mock_query):
+        # Simulate logs with identical message/severity in sequence
+        dt = self.now
+        logs = [
+            {
+                "project.id": self.project.id,
+                "timestamp": (dt - timedelta(seconds=3)).isoformat(),
+                "message": "foo",
+                "severity": "info",
+            },
+            {
+                "project.id": self.project.id,
+                "timestamp": (dt - timedelta(seconds=2)).isoformat(),
+                "message": "foo",
+                "severity": "info",
+            },
+            {
+                "project.id": self.project.id,
+                "timestamp": (dt - timedelta(seconds=1)).isoformat(),
+                "message": "bar",
+                "severity": "error",
+            },
+            {
+                "project.id": self.project.id,
+                "timestamp": dt.isoformat(),
+                "message": "foo",
+                "severity": "info",
+            },
+        ]
+        mock_query.return_value = {"data": logs}
+        # Use a mock event with datetime at dt
+        event = Mock()
+        event.trace_id = self.trace_id
+        event.datetime = dt
+        project = self.project
+        # Patch project.organization to avoid DB hits
+        project.organization = self.organization
+        merged = _get_logs_for_event(event, project)
+        assert merged is not None
+        # The first two "foo" logs should be merged (consecutive), the last "foo" is not consecutive
+        foo_merged = [
+            log for log in merged if log["message"] == "foo" and log.get("consecutive_count") == 2
+        ]
+        foo_single = [
+            log for log in merged if log["message"] == "foo" and "consecutive_count" not in log
+        ]
+        bar = [log for log in merged if log["message"] == "bar"]
+        assert len(foo_merged) == 1
+        assert len(foo_single) == 1
+        assert len(bar) == 1
+        # Order: merged foo, bar, single foo
+        assert merged[0]["message"] == "foo" and merged[0]["consecutive_count"] == 2
+        assert merged[1]["message"] == "bar"
+        assert merged[2]["message"] == "foo" and "consecutive_count" not in merged[2]