feat(grouping): Store grouping-method-specific metadata in GroupHashMetadata (#80534)

This is a follow-up to #80531 (which added a new `hashing_metaadata` field to the `GroupHashMetadata` table), adding code to actual store data in the new field.

Author: lobsterkatie

src/sentry/grouping/ingest/grouphash_metadata.py

@@ -1,12 +1,43 @@
 from __future__ import annotations
 
 import logging
+from typing import Any, cast
 
 from sentry.eventstore.models import Event
-from sentry.grouping.variants import BaseVariant
+from sentry.grouping.component import (
+    ChainedExceptionGroupingComponent,
+    CSPGroupingComponent,
+    ExceptionGroupingComponent,
+    ExpectCTGroupingComponent,
+    ExpectStapleGroupingComponent,
+    HPKPGroupingComponent,
+    MessageGroupingComponent,
+    StacktraceGroupingComponent,
+    TemplateGroupingComponent,
+    ThreadsGroupingComponent,
+)
+from sentry.grouping.variants import (
+    BaseVariant,
+    ChecksumVariant,
+    ComponentVariant,
+    CustomFingerprintVariant,
+    HashedChecksumVariant,
+    SaltedComponentVariant,
+    VariantsByDescriptor,
+)
 from sentry.models.grouphash import GroupHash
 from sentry.models.grouphashmetadata import GroupHashMetadata, HashBasis
 from sentry.models.project import Project
+from sentry.types.grouphash_metadata import (
+    ChecksumHashingMetadata,
+    FallbackHashingMetadata,
+    FingerprintHashingMetadata,
+    HashingMetadata,
+    MessageHashingMetadata,
+    SecurityHashingMetadata,
+    StacktraceHashingMetadata,
+    TemplateHashingMetadata,
+)
 
 logger = logging.getLogger(__name__)
 
@@ -57,12 +88,13 @@ def create_or_update_grouphash_metadata(
     # we'll have to override the metadata creation date for them.
 
     if created:
-        hash_basis = _get_hash_basis(event, project, variants)
+        hash_basis, hashing_metadata = get_hash_basis_and_metadata(event, project, variants)
 
         GroupHashMetadata.objects.create(
             grouphash=grouphash,
             latest_grouping_config=grouping_config,
             hash_basis=hash_basis,
+            hashing_metadata=hashing_metadata,
         )
     elif grouphash.metadata and grouphash.metadata.latest_grouping_config != grouping_config:
         # Keep track of the most recent config which computed this hash, so that once a
@@ -71,8 +103,16 @@ def create_or_update_grouphash_metadata(
         grouphash.metadata.update(latest_grouping_config=grouping_config)
 
 
-def _get_hash_basis(event: Event, project: Project, variants: dict[str, BaseVariant]) -> HashBasis:
-    main_variant = (
+def get_hash_basis_and_metadata(
+    event: Event, project: Project, variants: dict[str, BaseVariant]
+) -> tuple[HashBasis, HashingMetadata]:
+    hashing_metadata: HashingMetadata = {}
+
+    # TODO: This (and `contributing_variant` below) are typed as `Any` so that we don't have to cast
+    # them to whatever specific subtypes of `BaseVariant` and `GroupingComponent` (respectively)
+    # each of the helper calls below requires. Casting once, to a type retrieved from a look-up,
+    # doesn't work, but maybe there's a better way?
+    contributing_variant: Any = (
         variants["app"]
         # TODO: We won't need this 'if' once we stop returning both app and system contributing
         # variants
@@ -87,20 +127,246 @@ def _get_hash_basis(event: Event, project: Project, variants: dict[str, BaseVari
             else [variant for variant in variants.values() if variant.contributes][0]
         )
     )
+    contributing_component: Any = (
+        # There should only ever be a single contributing component here at the top level
+        [value for value in contributing_variant.component.values if value.contributes][0]
+        if hasattr(contributing_variant, "component")
+        else None
+    )
+
+    # Hybrid fingerprinting adds 'modified' to the beginning of the description of whatever method
+    # was used before the extra fingerprint was added. We classify events with hybrid fingerprints
+    # by the `{{ default }}` portion of their grouping, so strip the prefix before doing the
+    # look-up.
+    is_hybrid_fingerprint = contributing_variant.description.startswith("modified")
+    method_description = contributing_variant.description.replace("modified ", "")
 
     try:
-        hash_basis = GROUPING_METHODS_BY_DESCRIPTION[
-            # Hybrid fingerprinting adds 'modified' to the beginning of the description of whatever
-            # method was used beore the extra fingerprint was added, so strip that off before
-            # looking it up
-            main_variant.description.replace("modified ", "")
-        ]
+        hash_basis = GROUPING_METHODS_BY_DESCRIPTION[method_description]
     except KeyError:
         logger.exception(
             "Encountered unknown grouping method '%s'.",
-            main_variant.description,
+            contributing_variant.description,
             extra={"project": project.id, "event": event.event_id},
         )
-        hash_basis = HashBasis.UNKNOWN
+        return (HashBasis.UNKNOWN, {})
+
+    # Gather different metadata depending on the grouping method
+
+    if hash_basis == HashBasis.STACKTRACE:
+        hashing_metadata = _get_stacktrace_hashing_metadata(
+            contributing_variant, contributing_component
+        )
+
+    elif hash_basis == HashBasis.MESSAGE:
+        hashing_metadata = _get_message_hashing_metadata(contributing_component)
+
+    elif hash_basis == HashBasis.FINGERPRINT:
+        hashing_metadata = _get_fingerprint_hashing_metadata(contributing_variant)
+
+    elif hash_basis == HashBasis.SECURITY_VIOLATION:
+        hashing_metadata = _get_security_hashing_metadata(contributing_component)
+
+    elif hash_basis == HashBasis.TEMPLATE:
+        hashing_metadata = _get_template_hashing_metadata(contributing_component)
+
+    elif hash_basis == HashBasis.CHECKSUM:
+        hashing_metadata = _get_checksum_hashing_metadata(contributing_variant)
+
+    elif hash_basis == HashBasis.FALLBACK:
+        hashing_metadata = _get_fallback_hashing_metadata(
+            # TODO: Once https://peps.python.org/pep-0728 is a thing (still in draft but
+            # theoretically on track for 3.14), we can mark `VariantsByDescriptor` as closed and
+            # annotate `variants` as a `VariantsByDescriptor` instance in the spot where it's created
+            # and in all of the spots where it gets passed function to function. (Without the
+            # closed-ness, the return values of `.items()` and `.values()` don't get typed as
+            # `BaseVariant`, so for now we need to keep `variants` typed as `dict[str, BaseVariant]`
+            # until we get here.)
+            cast(VariantsByDescriptor, variants)
+        )
+
+    if is_hybrid_fingerprint:
+        hashing_metadata.update(
+            _get_fingerprint_hashing_metadata(contributing_variant, is_hybrid=True)
+        )
+
+    return hash_basis, hashing_metadata
+
+
+def _get_stacktrace_hashing_metadata(
+    contributing_variant: ComponentVariant,
+    contributing_component: (
+        StacktraceGroupingComponent
+        | ExceptionGroupingComponent
+        | ChainedExceptionGroupingComponent
+        | ThreadsGroupingComponent
+    ),
+) -> StacktraceHashingMetadata:
+    return {
+        "stacktrace_type": "in_app" if "in-app" in contributing_variant.description else "system",
+        "stacktrace_location": (
+            "exception"
+            if "exception" in contributing_variant.description
+            else "thread" if "thread" in contributing_variant.description else "top-level"
+        ),
+        "num_stacktraces": (
+            len(contributing_component.values)
+            if contributing_component.id == "chained-exception"
+            else 1
+        ),
+    }
+
+
+def _get_message_hashing_metadata(
+    contributing_component: (
+        MessageGroupingComponent | ExceptionGroupingComponent | ChainedExceptionGroupingComponent
+    ),
+) -> MessageHashingMetadata:
+    # In the simplest case, we already have the component we need to check
+    if isinstance(contributing_component, MessageGroupingComponent):
+        return {
+            "message_source": "message",
+            "message_parameterized": (
+                contributing_component.hint == "stripped event-specific values"
+            ),
+        }
+
+    # Otherwise, we have to look in the nested structure to figure out if the message was
+    # parameterized. If it's a single exception, we can just check its subcomponents directly, but
+    # if it's a chained exception we have to dig in an extra level, and look at the subcomponents of
+    # all of its children. (The subcomponents are things like stacktrace, error type, error value,
+    # etc.)
+    exceptions_to_check: list[ExceptionGroupingComponent] = []
+    if isinstance(contributing_component, ChainedExceptionGroupingComponent):
+        exceptions = contributing_component.values
+        exceptions_to_check = [exception for exception in exceptions if exception.contributes]
+    else:
+        exception = contributing_component
+        exceptions_to_check = [exception]
+
+    for exception in exceptions_to_check:
+        for subcomponent in exception.values:
+            if subcomponent.contributes and subcomponent.hint == "stripped event-specific values":
+                return {"message_source": "exception", "message_parameterized": True}
+
+    return {"message_source": "exception", "message_parameterized": False}
+
+
+def _get_fingerprint_hashing_metadata(
+    contributing_variant: CustomFingerprintVariant | SaltedComponentVariant, is_hybrid: bool = False
+) -> FingerprintHashingMetadata:
+    client_fingerprint = contributing_variant.info.get("client_fingerprint")
+    matched_rule = contributing_variant.info.get("matched_rule")
+
+    metadata: FingerprintHashingMetadata = {
+        # For simplicity, we stringify fingerprint values (which are always lists) to keep
+        # `hashing_metadata` a flat structure
+        "fingerprint": str(contributing_variant.values),
+        "fingerprint_source": (
+            "client"
+            if not matched_rule
+            else (
+                "server_builtin_rule"
+                if contributing_variant.type == "built_in_fingerprint"
+                else "server_custom_rule"
+            )
+        ),
+        "is_hybrid_fingerprint": is_hybrid,
+    }
+
+    # Note that these two conditions are not mutually exclusive - you can set a fingerprint in the
+    # SDK and have your event match a server-based rule (in which case the latter will take
+    # precedence)
+    if matched_rule:
+        metadata["matched_fingerprinting_rule"] = matched_rule["text"]
+    if client_fingerprint:
+        metadata["client_fingerprint"] = str(client_fingerprint)
+
+    return metadata
+
+
+def _get_security_hashing_metadata(
+    contributing_component: (
+        CSPGroupingComponent
+        | ExpectCTGroupingComponent
+        | ExpectStapleGroupingComponent
+        | HPKPGroupingComponent
+    ),
+) -> SecurityHashingMetadata:
+    subcomponents_by_id = {
+        subcomponent.id: subcomponent for subcomponent in contributing_component.values
+    }
+    blocked_host_key = "uri" if contributing_component.id == "csp" else "hostname"
+
+    metadata: SecurityHashingMetadata = {
+        "security_report_type": contributing_component.id,
+        # Having a string which includes the "this is a string" quotes is a *real* footgun in terms
+        # of querying, so strip those off before storing the value
+        "blocked_host": subcomponents_by_id[blocked_host_key].values[0].strip("'"),
+    }
+
+    if contributing_component.id == "csp":
+        metadata["csp_directive"] = subcomponents_by_id["salt"].values[0]
+        if subcomponents_by_id["violation"].contributes:
+            metadata["csp_script_violation"] = subcomponents_by_id["violation"].values[0].strip("'")
+
+    return metadata
+
+
+def _get_template_hashing_metadata(
+    contributing_component: TemplateGroupingComponent,
+) -> TemplateHashingMetadata:
+    metadata: TemplateHashingMetadata = {}
+
+    subcomponents_by_id = {
+        subcomponent.id: subcomponent for subcomponent in contributing_component.values
+    }
+
+    if subcomponents_by_id["filename"].values:
+        metadata["template_name"] = subcomponents_by_id["filename"].values[0]
+    if subcomponents_by_id["context-line"].values:
+        metadata["template_context_line"] = subcomponents_by_id["context-line"].values[0]
+
+    return metadata
+
+
+def _get_checksum_hashing_metadata(
+    contributing_variant: ChecksumVariant | HashedChecksumVariant,
+) -> ChecksumHashingMetadata:
+    metadata: ChecksumHashingMetadata = {"checksum": contributing_variant.checksum}
+
+    if isinstance(contributing_variant, HashedChecksumVariant):
+        metadata["raw_checksum"] = contributing_variant.raw_checksum
+
+    return metadata
+
+
+def _get_fallback_hashing_metadata(
+    variants: VariantsByDescriptor,
+) -> FallbackHashingMetadata:
+    # TODO: All of the specific cases handled below relate to stacktrace frames. Let's how often we
+    # land in the `other` category and then we can decide how much further it's worthwhile to break
+    # it down.
+
+    if (
+        "app" in variants
+        and variants["app"].component.values[0].hint == "ignored because it contains no frames"
+    ):
+        reason = "no_frames"
+
+    elif (
+        "system" in variants
+        and variants["system"].component.values[0].hint
+        == "ignored because it contains no contributing frames"
+    ):
+        reason = "no_contributing_frames"
+
+    elif "system" in variants and "min-frames" in (
+        variants["system"].component.values[0].hint or ""
+    ):
+        reason = "insufficient_contributing_frames"
+
+    else:
+        reason = "other"
 
-    return hash_basis
+    return {"fallback_reason": reason}

src/sentry/grouping/variants.py

@@ -1,5 +1,7 @@
 from __future__ import annotations
 
+from typing import TypedDict
+
 from sentry.grouping.utils import hash_from_values, is_default_fingerprint_var
 from sentry.types.misc import KeyedList
 
@@ -213,3 +215,14 @@ def _get_metadata_as_dict(self):
         rv = ComponentVariant._get_metadata_as_dict(self)
         rv.update(expose_fingerprint_dict(self.values, self.info))
         return rv
+
+
+class VariantsByDescriptor(TypedDict, total=False):
+    system: ComponentVariant
+    app: ComponentVariant
+    custom_fingerprint: CustomFingerprintVariant
+    built_in_fingerprint: BuiltInFingerprintVariant
+    checksum: ChecksumVariant
+    hashed_checksum: HashedChecksumVariant
+    default: ComponentVariant
+    fallback: FallbackVariant

tests/sentry/grouping/snapshots/test_grouphash_metadata/test_metadata_from_variants/legacy@2019_03_12/actix.pysnap

@@ -1,9 +1,14 @@
 ---
-created: '2024-10-28T14:02:48.633593+00:00'
+created: '2024-11-08T19:20:22.951550+00:00'
 creator: sentry
 source: tests/sentry/grouping/test_grouphash_metadata.py
 ---
 hash_basis: stacktrace
+hashing_metadata: {
+  "num_stacktraces": 1,
+  "stacktrace_location": "exception",
+  "stacktrace_type": "in_app"
+}
 ---
 contributing variants:
   app*

tests/sentry/grouping/snapshots/test_grouphash_metadata/test_metadata_from_variants/legacy@2019_03_12/android_anr.pysnap

@@ -1,9 +1,14 @@
 ---
-created: '2024-10-28T14:02:48.697072+00:00'
+created: '2024-11-08T19:20:23.312203+00:00'
 creator: sentry
 source: tests/sentry/grouping/test_grouphash_metadata.py
 ---
 hash_basis: stacktrace
+hashing_metadata: {
+  "num_stacktraces": 1,
+  "stacktrace_location": "exception",
+  "stacktrace_type": "system"
+}
 ---
 contributing variants:
   system*