feat(bug-prediction): Allow exception type string format to be flexible (#99617)

Make the input to query to get issues by exception type to be case
insensitive and ignore non alphanumeric characters.

For example when querying "ReactErrorBoundaryError" previously would not
match the issues with "React Error Boundary Error" as the type in the DB
### Legal Boilerplate

Look, I get it. The entity doing business as "Sentry" was incorporated
in the State of Delaware in 2015 as Functional Software, Inc. and is
gonna need some rights from me in order to utilize my contributions in
this here PR. So here's the deal: I retain all rights, title and
interest in and to my contributions, and by keeping this boilerplate
intact I confirm that Sentry can use, modify, copy, and redistribute my
contributions, under Sentry's choice of terms.

Author: JerrySentry

src/sentry/seer/fetch_issues/by_error_type.py

@@ -14,11 +14,23 @@ def _fetch_issues_from_repo_projects(
 ) -> list[Group]:
     project_ids = [project.id for project in repo_projects.projects]
     date_threshold = datetime.now(tz=UTC) - timedelta(days=num_days_ago)
+
+    # Normalize the search term by removing non-ASCII alphanumeric characters and converting to uppercase
+    # This matches the SQL regex [^a-zA-Z0-9] which only keeps ASCII alphanumeric characters
+    normalized_exception_type = "".join(
+        c.upper() for c in exception_type if c.isascii() and c.isalnum()
+    )
+
     # Using raw SQL since data is LegacyTextJSONField which can't be filtered with Django ORM
     query_set = (
-        Group.objects.annotate(metadata_type=RawSQL("(data::json -> 'metadata' ->> 'type')", []))
+        Group.objects.annotate(
+            metadata_type=RawSQL(
+                "UPPER(REGEXP_REPLACE(data::json -> 'metadata' ->> 'type', '[^a-zA-Z0-9]', '', 'g'))",
+                [],
+            )
+        )
         .filter(
-            metadata_type=exception_type,
+            metadata_type=normalized_exception_type,
             project_id__in=project_ids,
             last_seen__gte=date_threshold,
         )

tests/sentry/seer/fetch_issues/test_by_error_type.py

@@ -367,3 +367,173 @@ def test_fetch_issues_from_repo_projects_empty_result(self) -> None:
         # Verify it returns an empty list
         assert isinstance(results, list)
         assert len(results) == 0
+
+    def _setup_test_environment(
+        self, exception_type: str, exception_value: str = "Test error"
+    ) -> Group:
+        """Helper to set up test environment with a group containing the specified exception type."""
+        release = self.create_release(project=self.project, version="1.0.0")
+        repo = self.create_repo(
+            project=self.project,
+            name="getsentry/sentryA",
+            provider="integrations:github",
+            external_id="1",
+        )
+        self.create_code_mapping(project=self.project, repo=repo)
+
+        data = load_data("python", timestamp=before_now(minutes=1))
+        event = self.store_event(
+            data={
+                **data,
+                "release": release.version,
+                "exception": {
+                    "values": [
+                        {"type": exception_type, "value": exception_value, "data": {"values": []}}
+                    ]
+                },
+            },
+            project_id=self.project.id,
+        )
+        group = event.group
+        assert group is not None
+        group.save()
+        return group
+
+    def _assert_exception_type_matches(
+        self, search_exception_type: str, expected_group: Group
+    ) -> None:
+        """Helper to assert that a search exception type returns the expected group."""
+        seer_response = fetch_issues(
+            organization_id=self.organization.id,
+            provider="integrations:github",
+            external_id="1",
+            exception_type=search_exception_type,
+        )
+        assert seer_response["issues"] == [expected_group.id]
+        assert len(seer_response["issues_full"]) == 1
+
+    def _test_exception_type_variants(
+        self, stored_exception_type: str, search_variants: list[str]
+    ) -> None:
+        """Helper to test multiple search variants against a stored exception type."""
+        group = self._setup_test_environment(stored_exception_type)
+
+        for search_exception_type in search_variants:
+            with self.subTest(search_exception_type=search_exception_type):
+                self._assert_exception_type_matches(search_exception_type, group)
+
+    def test_case_insensitive_matching(self) -> None:
+        """Test that exception type matching is case insensitive."""
+        search_variants = ["TypeError", "typeerror", "TYPEERROR", "TypeERROR", "tYpEeRrOr"]
+        self._test_exception_type_variants("TypeError", search_variants)
+
+    def test_normalized_matching_spaces(self) -> None:
+        """Test that exception type matching normalizes spaces and special characters."""
+        search_variants = [
+            "Runtime Error",
+            "RuntimeError",
+            "runtime error",
+            "runtimeerror",
+            "RUNTIME ERROR",
+            "RUNTIMEERROR",
+            "runtime_error",
+            "runtime-error",
+        ]
+        self._test_exception_type_variants("Runtime Error", search_variants)
+
+    def test_normalized_matching_special_characters(self) -> None:
+        """Test that exception type matching normalizes various special characters."""
+        search_variants = [
+            "HTTP-404-Error",
+            "HTTP 404 Error",
+            "HTTP_404_Error",
+            "HTTP.404.Error",
+            "HTTP404Error",
+            "http404error",
+            "HTTP  404  Error",  # multiple spaces
+            "HTTP__404__Error",  # multiple underscores
+        ]
+        self._test_exception_type_variants("HTTP-404-Error", search_variants)
+
+    def test_normalized_matching_multiple_groups(self) -> None:
+        """Test normalized matching works correctly with multiple different exception types."""
+        release = self.create_release(project=self.project, version="1.0.0")
+        repo = self.create_repo(
+            project=self.project,
+            name="getsentry/sentryA",
+            provider="integrations:github",
+            external_id="1",
+        )
+        self.create_code_mapping(project=self.project, repo=repo)
+
+        # Create first group with "Value Error"
+        data1 = load_data("python", timestamp=before_now(minutes=1))
+        event1 = self.store_event(
+            data={
+                **data1,
+                "release": release.version,
+                "exception": {
+                    "values": [
+                        {"type": "Value Error", "value": "Bad value", "data": {"values": []}}
+                    ]
+                },
+            },
+            project_id=self.project.id,
+        )
+        group1 = event1.group
+        assert group1 is not None
+        group1.save()
+
+        # Create second group with "Type-Error"
+        data2 = load_data("python", timestamp=before_now(minutes=2))
+        event2 = self.store_event(
+            data={
+                **data2,
+                "release": release.version,
+                "exception": {
+                    "values": [{"type": "Type-Error", "value": "Bad type", "data": {"values": []}}]
+                },
+            },
+            project_id=self.project.id,
+        )
+        group2 = event2.group
+        assert group2 is not None
+        group2.save()
+
+        # Test that "valueerror" matches only the first group
+        seer_response = fetch_issues(
+            organization_id=self.organization.id,
+            provider="integrations:github",
+            external_id="1",
+            exception_type="valueerror",
+        )
+        assert seer_response["issues"] == [group1.id]
+        assert len(seer_response["issues_full"]) == 1
+
+        # Test that "type error" matches only the second group
+        seer_response = fetch_issues(
+            organization_id=self.organization.id,
+            provider="integrations:github",
+            external_id="1",
+            exception_type="type error",
+        )
+        assert seer_response["issues"] == [group2.id]
+        assert len(seer_response["issues_full"]) == 1
+
+        # Test that "runtimeerror" matches neither
+        seer_response = fetch_issues(
+            organization_id=self.organization.id,
+            provider="integrations:github",
+            external_id="1",
+            exception_type="runtimeerror",
+        )
+        assert seer_response == {"issues": [], "issues_full": []}
+
+    def test_unicode_normalization_consistency(self) -> None:
+        """Test that Unicode characters are handled consistently between Python and SQL."""
+        search_variants = [
+            "ValueError测试",  # Same Unicode as stored
+            "ValueError",  # Just ASCII part
+            "ValueError测试αβ",  # Different Unicode chars that normalize to same ASCII
+        ]
+        self._test_exception_type_variants("ValueError测试", search_variants)