ref(auto_source_config): Prepare for in-app creation

This is a no-op change that will reduce the burden of reviewing the next change.

Author: armenzg

src/sentry/issues/auto_source_code_config/task.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 import logging
-from collections.abc import MutableMapping
+from collections.abc import Mapping
 from enum import StrEnum
 from typing import Any
 
@@ -41,7 +41,9 @@ class DeriveCodeMappingsErrorReason(StrEnum):
     EMPTY_TREES = "The trees are empty."
 
 
-def process_event(project_id: int, group_id: int, event_id: str) -> list[CodeMapping]:
+def process_event(
+    project_id: int, group_id: int, event_id: str
+) -> tuple[list[CodeMapping], list[str]]:
     """
     Process errors for customers with source code management installed and calculate code mappings
     among other things.
@@ -64,31 +66,34 @@ def process_event(project_id: int, group_id: int, event_id: str) -> list[CodeMap
     event = eventstore.backend.get_event_by_id(project_id, event_id, group_id)
     if event is None:
         logger.error("Event not found.", extra=extra)
-        return []
+        return [], []
 
     platform = event.platform
     assert platform is not None
 
     platform_config = PlatformConfig(platform)
     if not platform_config.is_supported():
-        return []
+        return [], []
 
     frames_to_process = get_frames_to_process(event.data, platform)
     if not frames_to_process:
-        return []
+        return [], []
 
-    code_mappings = []
+    code_mappings: list[CodeMapping] = []
+    in_app_stack_trace_rules: list[str] = []
     try:
         installation = get_installation(org)
         trees = get_trees_for_org(installation, org, extra)
         trees_helper = CodeMappingTreesHelper(trees)
         code_mappings = trees_helper.generate_code_mappings(frames_to_process, platform)
-        dry_run = platform_config.is_dry_run_platform()
-        create_repos_and_code_mappings(code_mappings, installation, project, platform, dry_run)
+        _, in_app_stack_trace_rules = create_configurations(
+            code_mappings, installation, project, platform_config
+        )
+
     except (InstallationNotFoundError, InstallationCannotGetTreesError):
         pass
 
-    return code_mappings
+    return code_mappings, in_app_stack_trace_rules
 
 
 def process_error(error: ApiError, extra: dict[str, Any]) -> None:
@@ -161,23 +166,25 @@ def get_trees_for_org(
         return trees
 
 
-def create_repos_and_code_mappings(
+def create_configurations(
     code_mappings: list[CodeMapping],
     installation: IntegrationInstallation,
     project: Project,
-    platform: str,
-    dry_run: bool,
-) -> None:
+    platform_config: PlatformConfig,
+) -> tuple[list[CodeMapping], list[str]]:
     """
-    Given a list of code mappings, create a new repository project path
-    config for each mapping.
+    Given a set of trees and frames to process, create code mappings & in-app stack trace rules.
+
+    Returns a tuple of code mappings and in-app stack trace rules even when running in dry-run mode.
     """
     organization_integration = installation.org_integration
     if not organization_integration:
         raise InstallationNotFoundError
 
     organization_id = organization_integration.organization_id
-    tags: MutableMapping[str, str | bool] = {"platform": platform, "dry_run": dry_run}
+    dry_run = platform_config.is_dry_run_platform()
+    platform = platform_config.platform
+    tags: Mapping[str, str | bool] = {"platform": platform, "dry_run": dry_run}
     with metrics.timer(f"{METRIC_PREFIX}.create_configurations.duration", tags=tags):
         for code_mapping in code_mappings:
             repository = (
@@ -219,3 +226,12 @@ def create_repos_and_code_mappings(
                 metrics.incr(
                     key=f"{METRIC_PREFIX}.code_mapping.created", tags=tags, sample_rate=1.0
                 )
+
+    in_app_stack_trace_rules: list[str] = []
+    if platform_config.creates_in_app_stack_trace_rules():
+        # XXX: This will be changed on the next PR
+        pass
+
+    # We return this to allow tests running in dry-run mode to assert
+    # what would have been created.
+    return code_mappings, in_app_stack_trace_rules

tests/sentry/issues/auto_source_code_config/test_process_event.py

@@ -81,7 +81,8 @@ def _process_and_assert_code_mapping(
         expected_source_root: str,
         expected_repo_name: str = REPO1,
         expected_num_code_mappings: int = 1,
-    ) -> None:
+        expected_in_app_stack_trace_rules: list[str] | None = None,
+    ) -> GroupEvent:
         with (
             patch(f"{CLIENT}.get_tree", side_effect=create_mock_get_tree(repo_trees)),
             patch(f"{CLIENT}.get_remaining_api_requests", return_value=500),
@@ -94,8 +95,9 @@ def _process_and_assert_code_mapping(
             repositories_count = Repository.objects.all().count()
             code_mappings_count = RepositoryProjectPathConfig.objects.all().count()
             event = self.create_event(frames, platform)
-            process_event(self.project.id, event.group_id, event.event_id)
-
+            _, in_app_stack_trace_rules = process_event(
+                self.project.id, event.group_id, event.event_id
+            )
             code_mappings = RepositoryProjectPathConfig.objects.all()
             assert len(code_mappings) == expected_num_code_mappings
             code_mapping = code_mappings.filter(
@@ -118,14 +120,20 @@ def _process_and_assert_code_mapping(
                 mock_incr.assert_any_call(
                     key=f"{METRIC_PREFIX}.code_mapping.created", tags=tags, sample_rate=1.0
                 )
+            if expected_in_app_stack_trace_rules is not None:
+                # XXX: Grab it from the option
+                assert expected_in_app_stack_trace_rules == in_app_stack_trace_rules
+
+            # Returning this is useful to inspect hash changes
+            return event
 
     def _process_and_assert_no_code_mapping(
         self,
         *,  # Force keyword arguments
         repo_trees: Mapping[str, Sequence[str]],
         frames: Sequence[Mapping[str, str | bool]],
         platform: str,
-    ) -> list[CodeMapping]:
+    ) -> tuple[list[CodeMapping], list[str]]:
         with (
             patch(f"{CLIENT}.get_tree", side_effect=create_mock_get_tree(repo_trees)),
             patch(f"{CLIENT}.get_remaining_api_requests", return_value=500),
@@ -136,7 +144,9 @@ def _process_and_assert_no_code_mapping(
             patch("sentry.utils.metrics.incr") as mock_incr,
         ):
             event = self.create_event(frames, platform)
-            code_mappings = process_event(self.project.id, event.group_id, event.event_id)
+            code_mappings, in_app_stack_trace_rules = process_event(
+                self.project.id, event.group_id, event.event_id
+            )
             assert not RepositoryProjectPathConfig.objects.exists()
             platform_config = PlatformConfig(platform)
             dry_run = platform_config.is_dry_run_platform()
@@ -152,7 +162,7 @@ def _process_and_assert_no_code_mapping(
                     tags={"platform": event.platform, "dry_run": dry_run},
                     sample_rate=1.0,
                 )
-            return code_mappings
+            return code_mappings, in_app_stack_trace_rules
 
     def frame(self, filename: str, in_app: bool | None = True) -> dict[str, str | bool]:
         frame: dict[str, str | bool] = {"filename": filename}
@@ -242,7 +252,7 @@ def test_dry_run_platform(self) -> None:
             patch(f"{CODE_ROOT}.utils.PlatformConfig.is_dry_run_platform", return_value=True),
         ):
             # No code mapping will be stored, however, we get what would have been created
-            code_mappings = self._process_and_assert_no_code_mapping(
+            code_mappings, _ = self._process_and_assert_no_code_mapping(
                 repo_trees={REPO1: [file_in_repo]},
                 frames=[self.frame(frame_filename, True)],
                 platform=platform,
@@ -591,7 +601,7 @@ class TestJavaDeriveCodeMappings(LanguageSpecificDeriveCodeMappings):
 
     def test_very_short_module_name(self) -> None:
         # No code mapping will be stored, however, we get what would have been created
-        code_mappings = self._process_and_assert_no_code_mapping(
+        code_mappings, in_app_stack_trace_rules = self._process_and_assert_no_code_mapping(
             repo_trees={REPO1: ["src/a/SomeShortPackageNameClass.java"]},
             frames=[
                 {
@@ -604,10 +614,11 @@ def test_very_short_module_name(self) -> None:
         assert len(code_mappings) == 1
         assert code_mappings[0].stacktrace_root == "a/"
         assert code_mappings[0].source_path == "src/a/"
+        assert in_app_stack_trace_rules == ["stack.module:a.** +app"]
 
     def test_handles_dollar_sign_in_module(self) -> None:
         # No code mapping will be stored, however, we get what would have been created
-        code_mappings = self._process_and_assert_no_code_mapping(
+        code_mappings, in_app_stack_trace_rules = self._process_and_assert_no_code_mapping(
             repo_trees={REPO1: ["src/com/example/foo/Bar.kt"]},
             frames=[{"module": "com.example.foo.Bar$InnerClass", "abs_path": "Bar.kt"}],
             platform=self.platform,