Revert grouping, leave fingerprinting

Author: mujacica

src/sentry/grouping/component.py

@@ -19,8 +19,6 @@
     "exception": "exception",
     "stacktrace": "stacktrace",
     "threads": "thread",
-    "thread_id": "thread-id",
-    "thread_name": "thread-name",
     "hostname": "hostname",
     "violation": "violation",
     "uri": "URL",
@@ -273,10 +271,6 @@ class NSErrorGroupingComponent(
     id: str = "ns_error"
 
 
-class ThreadNameGroupingComponent(BaseGroupingComponent[str]):
-    id: str = "thread_name"
-
-
 FrameGroupingComponentChild = (
     ContextLineGroupingComponent
     | FilenameGroupingComponent
@@ -465,28 +459,16 @@ class ThreadsGroupingComponent(BaseGroupingComponent[StacktraceGroupingComponent
     id: str = "threads"
     key: str = "thread_stacktrace"
     frame_counts: Counter[str]
-    metadata: list[BaseGroupingComponent[str]]
 
     def __init__(
         self,
         values: Sequence[StacktraceGroupingComponent] | None = None,
         hint: str | None = None,
         contributes: bool | None = None,
         frame_counts: Counter[str] | None = None,
-        metadata: list[BaseGroupingComponent[str]] | None = None,
     ):
         super().__init__(hint=hint, contributes=contributes, values=values)
         self.frame_counts = frame_counts or Counter()
-        self.metadata = metadata or []
-
-    def iter_values(self) -> Generator[str | int]:
-        """Include both stacktrace values and metadata in hash calculation."""
-        # First yield values from stacktrace components
-        yield from super().iter_values()
-        # Then yield values from metadata components
-        for meta in self.metadata:
-            if meta.contributes:
-                yield from meta.iter_values()
 
 
 class CSPGroupingComponent(

tests/sentry/grouping/test_strategies.py

@@ -2,12 +2,7 @@
 
 import pytest
 
-from sentry.grouping.api import load_grouping_config
-from sentry.grouping.component import (
-    StacktraceGroupingComponent,
-    ThreadNameGroupingComponent,
-    ThreadsGroupingComponent,
-)
+from sentry.grouping.component import StacktraceGroupingComponent
 from sentry.grouping.strategies.base import GroupingContext, create_strategy_configuration_class
 from sentry.services.eventstore.models import Event
 from sentry.testutils.cases import TestCase
@@ -304,162 +299,3 @@ def test_stacktrace_contribution_values_no_contributing_frames(self) -> None:
         assert (
             system_stacktrace_component.hint == "ignored because it contains no contributing frames"
         )
-
-
-class ThreadGroupingTest(TestCase):
-    """Tests for thread metadata in automatic grouping"""
-
-    def test_thread_name_grouping_enabled(self) -> None:
-        """Test that thread name contributes to grouping when enabled"""
-        # Create two events with same stacktrace but different thread names
-        # Use threads-only (no exception) to test thread grouping
-        event_main_thread = save_new_event(
-            {
-                "threads": {
-                    "values": [
-                        {
-                            "id": "1",
-                            "name": "MainThread",
-                            "crashed": True,
-                            "current": False,
-                            "stacktrace": {
-                                "frames": [
-                                    {"function": "query", "module": "app.db", "in_app": True}
-                                ]
-                            },
-                        }
-                    ]
-                },
-            },
-            self.project,
-        )
-
-        event_worker_thread = save_new_event(
-            {
-                "threads": {
-                    "values": [
-                        {
-                            "id": "2",
-                            "name": "WorkerThread",
-                            "crashed": True,
-                            "current": False,
-                            "stacktrace": {
-                                "frames": [
-                                    {"function": "query", "module": "app.db", "in_app": True}
-                                ]
-                            },
-                        }
-                    ]
-                },
-            },
-            self.project,
-        )
-
-        # With thread name grouping enabled
-        config_with_threads = load_grouping_config(
-            {"id": "newstyle:2025-with-threads", "enhancements": None}
-        )
-
-        variants_main = event_main_thread.get_grouping_variants(force_config=config_with_threads)
-        variants_worker = event_worker_thread.get_grouping_variants(
-            force_config=config_with_threads
-        )
-
-        # They should have different hashes because thread names differ
-        assert variants_main["app"].get_hash() is not None, "Main thread variant should have a hash"
-        assert (
-            variants_worker["app"].get_hash() is not None
-        ), "Worker thread variant should have a hash"
-        assert (
-            variants_main["app"].get_hash() != variants_worker["app"].get_hash()
-        ), "Different thread names should produce different hashes"
-
-    def test_thread_name_grouping_disabled(self) -> None:
-        """Test that without thread grouping, threads don't affect grouping"""
-        event_main_thread = save_new_event(
-            {
-                "threads": {
-                    "values": [
-                        {
-                            "id": "1",
-                            "name": "MainThread",
-                            "crashed": True,
-                            "stacktrace": {
-                                "frames": [
-                                    {"function": "query", "module": "app.db", "in_app": True}
-                                ]
-                            },
-                        }
-                    ]
-                },
-            },
-            self.project,
-        )
-
-        event_worker_thread = save_new_event(
-            {
-                "threads": {
-                    "values": [
-                        {
-                            "id": "2",
-                            "name": "WorkerThread",
-                            "crashed": True,
-                            "stacktrace": {
-                                "frames": [
-                                    {"function": "query", "module": "app.db", "in_app": True}
-                                ]
-                            },
-                        }
-                    ]
-                },
-            },
-            self.project,
-        )
-
-        # Default config without thread grouping
-        config_default = load_grouping_config({"id": "newstyle:2023-01-11", "enhancements": None})
-
-        variants_main = event_main_thread.get_grouping_variants(force_config=config_default)
-        variants_worker = event_worker_thread.get_grouping_variants(force_config=config_default)
-
-        # They should have the same hash - thread name doesn't matter without the config
-        assert variants_main["app"].get_hash() == variants_worker["app"].get_hash()
-
-    def test_thread_metadata_component_structure(self) -> None:
-        """Test that thread metadata components are structured correctly"""
-        event = save_new_event(
-            {
-                "threads": {
-                    "values": [
-                        {
-                            "name": "MainThread",
-                            "crashed": True,
-                            "stacktrace": {"frames": [{"function": "main", "in_app": True}]},
-                        }
-                    ]
-                },
-            },
-            self.project,
-        )
-
-        config = load_grouping_config({"id": "newstyle:2025-with-threads", "enhancements": None})
-
-        variants = event.get_grouping_variants(force_config=config)
-        threads_component = variants["app"].contributing_component
-
-        # The contributing component should be a ThreadsGroupingComponent
-        assert isinstance(threads_component, ThreadsGroupingComponent)
-
-        # Check that thread metadata is accessible
-        assert len(threads_component.metadata) > 0, "Thread metadata should be present"
-
-        # Find the ThreadNameGroupingComponent in metadata
-        thread_name_component = next(
-            (m for m in threads_component.metadata if isinstance(m, ThreadNameGroupingComponent)),
-            None,
-        )
-        assert (
-            thread_name_component is not None
-        ), "ThreadNameGroupingComponent not found in metadata"
-        assert thread_name_component.values == ["MainThread"]
-        assert thread_name_component.contributes is True