s/GroupingComponent/BaseGroupingComponent

Author: lobsterkatie

src/sentry/grouping/__init__.py

@@ -87,7 +87,7 @@
 Here an example of how components can be used::
 
     function_name = 'lambda$1234'
-    threads = GroupingComponent(
+    threads = BaseGroupingComponent(
         id="function",
         values=[function_name],
         contributes=False,

src/sentry/grouping/api.py

@@ -8,7 +8,7 @@
 import sentry_sdk
 
 from sentry import options
-from sentry.grouping.component import GroupingComponent
+from sentry.grouping.component import BaseGroupingComponent
 from sentry.grouping.enhancer import LATEST_VERSION, Enhancements
 from sentry.grouping.enhancer.exceptions import InvalidEnhancerConfig
 from sentry.grouping.strategies.base import DEFAULT_GROUPING_ENHANCEMENTS_BASE, GroupingContext
@@ -264,10 +264,10 @@ def apply_server_fingerprinting(event, config, allow_custom_title=True):
 
 def _get_calculated_grouping_variants_for_event(
     event: Event, context: GroupingContext
-) -> dict[str, GroupingComponent]:
+) -> dict[str, BaseGroupingComponent]:
     winning_strategy: str | None = None
     precedence_hint: str | None = None
-    per_variant_components: dict[str, list[GroupingComponent]] = {}
+    per_variant_components: dict[str, list[BaseGroupingComponent]] = {}
 
     for strategy in context.config.iter_strategies():
         # Defined in src/sentry/grouping/strategies/base.py
@@ -292,7 +292,7 @@ def _get_calculated_grouping_variants_for_event(
 
     rv = {}
     for variant, components in per_variant_components.items():
-        component = GroupingComponent(id=variant, values=components)
+        component = BaseGroupingComponent(id=variant, values=components)
         if not component.contributes and precedence_hint:
             component.update(hint=precedence_hint)
         rv[variant] = component

src/sentry/grouping/component.py

@@ -23,29 +23,29 @@
 }
 
 
-def _calculate_contributes(values: Sequence[str | int | GroupingComponent]) -> bool:
+def _calculate_contributes(values: Sequence[str | int | BaseGroupingComponent]) -> bool:
     for value in values or ():
-        if not isinstance(value, GroupingComponent) or value.contributes:
+        if not isinstance(value, BaseGroupingComponent) or value.contributes:
             return True
     return False
 
 
-class GroupingComponent:
+class BaseGroupingComponent:
     """A grouping component is a recursive structure that is flattened
     into components to make a hash for grouping purposes.
     """
 
     id: str = "default"
     hint: str | None
     contributes: bool
-    values: Sequence[str | int | GroupingComponent]
+    values: Sequence[str | int | BaseGroupingComponent]
 
     def __init__(
         self,
         id: str | None = None,
         hint: str | None = None,
         contributes: bool | None = None,
-        values: Sequence[str | int | GroupingComponent] | None = None,
+        values: Sequence[str | int | BaseGroupingComponent] | None = None,
         variant_provider: bool = False,
     ):
         self.id = id or self.id
@@ -54,7 +54,7 @@ def __init__(
         self.hint = DEFAULT_HINTS.get(self.id)
         self.contributes = contributes
         self.variant_provider = variant_provider
-        self.values: Sequence[str | int | GroupingComponent] = []
+        self.values: Sequence[str | int | BaseGroupingComponent] = []
 
         self.update(
             hint=hint,
@@ -70,10 +70,10 @@ def name(self) -> str | None:
     def description(self) -> str:
         items = []
 
-        def _walk_components(c: GroupingComponent, stack: list[str | None]) -> None:
+        def _walk_components(c: BaseGroupingComponent, stack: list[str | None]) -> None:
             stack.append(c.name)
             for value in c.values:
-                if isinstance(value, GroupingComponent) and value.contributes:
+                if isinstance(value, BaseGroupingComponent) and value.contributes:
                     _walk_components(value, stack)
             parts = [_f for _f in stack if _f]
             items.append(parts)
@@ -89,16 +89,16 @@ def _walk_components(c: GroupingComponent, stack: list[str | None]) -> None:
 
     def get_subcomponent(
         self, id: str, only_contributing: bool = False
-    ) -> str | int | GroupingComponent | None:
+    ) -> str | int | BaseGroupingComponent | None:
         """Looks up a subcomponent by the id and returns the first or `None`."""
         return next(self.iter_subcomponents(id=id, only_contributing=only_contributing), None)
 
     def iter_subcomponents(
         self, id: str, recursive: bool = False, only_contributing: bool = False
-    ) -> Iterator[str | int | GroupingComponent | None]:
+    ) -> Iterator[str | int | BaseGroupingComponent | None]:
         """Finds all subcomponents matching an id, optionally recursively."""
         for value in self.values:
-            if isinstance(value, GroupingComponent):
+            if isinstance(value, BaseGroupingComponent):
                 if only_contributing and not value.contributes:
                     continue
                 if value.id == id:
@@ -113,7 +113,7 @@ def update(
         self,
         hint: str | None = None,
         contributes: bool | None = None,
-        values: Sequence[str | int | GroupingComponent] | None = None,
+        values: Sequence[str | int | BaseGroupingComponent] | None = None,
     ) -> None:
         """Updates an already existing component with new values."""
         if hint is not None:
@@ -125,20 +125,20 @@ def update(
         if contributes is not None:
             self.contributes = contributes
 
-    def shallow_copy(self) -> GroupingComponent:
+    def shallow_copy(self) -> BaseGroupingComponent:
         """Creates a shallow copy."""
         rv = object.__new__(self.__class__)
         rv.__dict__.update(self.__dict__)
         rv.values = list(self.values)
         return rv
 
-    def iter_values(self) -> Generator[str | int | GroupingComponent]:
+    def iter_values(self) -> Generator[str | int | BaseGroupingComponent]:
         """Recursively walks the component and flattens it into a list of
         values.
         """
         if self.contributes:
             for value in self.values:
-                if isinstance(value, GroupingComponent):
+                if isinstance(value, BaseGroupingComponent):
                     yield from value.iter_values()
                 else:
                     yield value
@@ -160,7 +160,7 @@ def as_dict(self) -> dict[str, Any]:
             "values": [],
         }
         for value in self.values:
-            if isinstance(value, GroupingComponent):
+            if isinstance(value, BaseGroupingComponent):
                 rv["values"].append(value.as_dict())
             else:
                 # This basically assumes that a value is only a primitive

src/sentry/grouping/enhancer/__init__.py

@@ -15,7 +15,7 @@
 from sentry_ophio.enhancers import Enhancements as RustEnhancements
 
 from sentry import projectoptions
-from sentry.grouping.component import GroupingComponent
+from sentry.grouping.component import BaseGroupingComponent
 from sentry.stacktraces.functions import set_in_app
 from sentry.utils.safe import get_path, set_path
 
@@ -179,7 +179,7 @@ def assemble_stacktrace_component(self, components, frames, platform, exception_
         for py_component, rust_component in zip(components, rust_components):
             py_component.update(contributes=rust_component.contributes, hint=rust_component.hint)
 
-        component = GroupingComponent(
+        component = BaseGroupingComponent(
             id="stacktrace",
             values=components,
             hint=rust_results.hint,

src/sentry/grouping/strategies/base.py

@@ -4,7 +4,7 @@
 
 from sentry import projectoptions
 from sentry.eventstore.models import Event
-from sentry.grouping.component import GroupingComponent
+from sentry.grouping.component import BaseGroupingComponent, GroupingComponent
 from sentry.grouping.enhancer import Enhancements
 from sentry.interfaces.base import Interface
 
@@ -117,7 +117,7 @@ def get_grouping_component(
 
     def get_single_grouping_component(
         self, interface: Interface, *, event: Event, **kwargs: Any
-    ) -> GroupingComponent:
+    ) -> BaseGroupingComponent:
         """Invokes a delegate grouping strategy.  If no such delegate is
         configured a fallback grouping component is returned.
         """
@@ -193,7 +193,7 @@ def variant_processor(self, func: VariantProcessor) -> VariantProcessor:
 
     def get_grouping_component(
         self, event: Event, context: GroupingContext, variant: str | None = None
-    ) -> None | GroupingComponent | ReturnedVariants:
+    ) -> None | BaseGroupingComponent | ReturnedVariants:
         """Given a specific variant this calculates the grouping component."""
         args = []
         iface = event.interfaces.get(self.interface)

src/sentry/grouping/strategies/legacy.py

@@ -3,7 +3,7 @@
 from typing import Any
 
 from sentry.eventstore.models import Event
-from sentry.grouping.component import GroupingComponent
+from sentry.grouping.component import BaseGroupingComponent
 from sentry.grouping.strategies.base import (
     GroupingContext,
     ReturnedVariants,
@@ -164,17 +164,17 @@ def single_exception_legacy(
     interface: SingleException, event: Event, context: GroupingContext, **meta: Any
 ) -> ReturnedVariants:
 
-    type_component = GroupingComponent(
+    type_component = BaseGroupingComponent(
         id="type",
         values=[interface.type] if interface.type else [],
         contributes=False,
     )
-    value_component = GroupingComponent(
+    value_component = BaseGroupingComponent(
         id="value",
         values=[interface.value] if interface.value else [],
         contributes=False,
     )
-    stacktrace_component = GroupingComponent(id="stacktrace")
+    stacktrace_component = BaseGroupingComponent(id="stacktrace")
 
     if interface.stacktrace is not None:
         stacktrace_component = context.get_single_grouping_component(
@@ -195,7 +195,7 @@ def single_exception_legacy(
             value_component.update(contributes=True)
 
     return {
-        context["variant"]: GroupingComponent(
+        context["variant"]: BaseGroupingComponent(
             id="exception", values=[stacktrace_component, type_component, value_component]
         )
     }
@@ -231,7 +231,7 @@ def chained_exception_legacy(
             if stacktrace_component is None or not stacktrace_component.contributes:
                 value.update(contributes=False, hint="exception has no stacktrace")
 
-    return {context["variant"]: GroupingComponent(id="chained-exception", values=values)}
+    return {context["variant"]: BaseGroupingComponent(id="chained-exception", values=values)}
 
 
 @chained_exception_legacy.variant_processor
@@ -262,7 +262,7 @@ def frame_legacy(
     # Safari throws [native code] frames in for calls like ``forEach``
     # whereas Chrome ignores these. Let's remove it from the hashing algo
     # so that they're more likely to group together
-    filename_component = GroupingComponent(id="filename")
+    filename_component = BaseGroupingComponent(id="filename")
     if interface.filename == "<anonymous>":
         filename_component.update(
             contributes=False, values=[interface.filename], hint="anonymous filename discarded"
@@ -293,12 +293,12 @@ def frame_legacy(
     # if we have a module we use that for grouping.  This will always
     # take precedence over the filename, even if the module is
     # considered unhashable.
-    module_component = GroupingComponent(id="module")
+    module_component = BaseGroupingComponent(id="module")
     if interface.module:
         if is_unhashable_module_legacy(interface, platform):
             module_component.update(
                 values=[
-                    GroupingComponent(
+                    BaseGroupingComponent(
                         id="salt", values=["<module>"], hint="normalized generated module name"
                     )
                 ],
@@ -313,7 +313,7 @@ def frame_legacy(
             )
 
     # Context line when available is the primary contributor
-    context_line_component = GroupingComponent(id="context-line")
+    context_line_component = BaseGroupingComponent(id="context-line")
     if interface.context_line is not None:
         if len(interface.context_line) > 120:
             context_line_component.update(hint="discarded because line too long")
@@ -322,9 +322,9 @@ def frame_legacy(
         else:
             context_line_component.update(values=[interface.context_line])
 
-    symbol_component = GroupingComponent(id="symbol")
-    function_component = GroupingComponent(id="function")
-    lineno_component = GroupingComponent(id="lineno")
+    symbol_component = BaseGroupingComponent(id="symbol")
+    function_component = BaseGroupingComponent(id="function")
+    lineno_component = BaseGroupingComponent(id="lineno")
 
     # The context line grouping information is the most reliable one.
     # If we did not manage to find some information there, we want to
@@ -347,7 +347,7 @@ def frame_legacy(
             if is_unhashable_function_legacy(func):
                 function_component.update(
                     values=[
-                        GroupingComponent(
+                        BaseGroupingComponent(
                             id="salt", values=["<function>"], hint="normalized lambda function name"
                         )
                     ]
@@ -380,7 +380,7 @@ def frame_legacy(
             )
 
     return {
-        context["variant"]: GroupingComponent(
+        context["variant"]: BaseGroupingComponent(
             id="frame",
             values=[
                 module_component,
@@ -461,7 +461,7 @@ def threads_legacy(
     thread_count = len(interface.values)
     if thread_count != 1:
         return {
-            context["variant"]: GroupingComponent(
+            context["variant"]: BaseGroupingComponent(
                 id="threads",
                 contributes=False,
                 hint="ignored because contains %d threads" % thread_count,
@@ -471,13 +471,13 @@ def threads_legacy(
     stacktrace = interface.values[0].get("stacktrace")
     if not stacktrace:
         return {
-            context["variant"]: GroupingComponent(
+            context["variant"]: BaseGroupingComponent(
                 id="threads", contributes=False, hint="thread has no stacktrace"
             )
         }
 
     return {
-        context["variant"]: GroupingComponent(
+        context["variant"]: BaseGroupingComponent(
             id="threads",
             values=[context.get_single_grouping_component(stacktrace, event=event, **meta)],
         )

src/sentry/grouping/strategies/message.py

@@ -4,7 +4,7 @@
 from sentry import analytics
 from sentry.eventstore.models import Event
 from sentry.features.rollout import in_rollout_group
-from sentry.grouping.component import GroupingComponent
+from sentry.grouping.component import BaseGroupingComponent
 from sentry.grouping.parameterization import Parameterizer, UniqueIdExperiment
 from sentry.grouping.strategies.base import (
     GroupingContext,
@@ -109,15 +109,15 @@ def message_v1(
         normalized = normalize_message_for_grouping(raw, event)
         hint = "stripped event-specific values" if raw != normalized else None
         return {
-            context["variant"]: GroupingComponent(
+            context["variant"]: BaseGroupingComponent(
                 id="message",
                 values=[normalized],
                 hint=hint,
             )
         }
     else:
         return {
-            context["variant"]: GroupingComponent(
+            context["variant"]: BaseGroupingComponent(
                 id="message",
                 values=[interface.message or interface.formatted or ""],
             )