feat(flutter): deobfuscate exception value occurrences of Instance of 'xyz' (#97668)

Currently for dart/flutter we get the symbol map and map the obfuscated
exception type to the de-obfuscated one.

Additionally `Instance of 'xyz'` where xyz is obfuscated also occurs
very often in the exception value.

This PR adds support for de-obfuscating these occurrences within the
exception value as well.

---------

Co-authored-by: getsantry[bot] <66042841+getsantry[bot]@users.noreply.github.com>

Author: buenaflor

src/sentry/lang/dart/utils.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import os
+import re
 from collections.abc import MutableMapping
 from typing import Any
 
@@ -16,6 +17,7 @@
 # the values to be more complicated such as "_xyz", so the regex should capture
 # any values other than "<" and ">".
 # VIEW_HIERARCHY_TYPE_REGEX = re.compile(r"([^<>]+)(?:<([^<>]+)>)?")
+INSTANCE_OF_VALUE_RE = re.compile(r"Instance of '([^']+)'")
 
 
 def get_debug_meta_image_ids(event: dict[str, Any]) -> set[str]:
@@ -63,9 +65,13 @@ def generate_dart_symbols_map(debug_ids: list[str], project: Project):
 
 def deobfuscate_exception_type(data: MutableMapping[str, Any]):
     """
-    Deobfuscates exception types in-place.
+    Deobfuscates exception types and certain values in-place.
 
-    If we're unable to fetch a dart symbols mapping file, then the exception types remain unmodified.
+    - Exception type: replaced directly via symbol map lookup
+    - Exception value: deobfuscate the quoted symbol for all occurrences of the
+      pattern "Instance of 'obfuscated_symbol'" in the value.
+
+    If we're unable to fetch a dart symbols mapping file, then the exception data remains unmodified.
     """
     project = Project.objects.get_from_cache(id=data["project"])
 
@@ -84,20 +90,25 @@ def deobfuscate_exception_type(data: MutableMapping[str, Any]):
 
         for exception in exceptions:
             exception_type = exception.get("type")
-            if exception_type is None:
-                continue
-
-            deobfuscated_type = symbol_map.get(exception_type)
-            if deobfuscated_type is not None:
-                exception["type"] = deobfuscated_type
-
-        # TODO(buenaflor): Future enhancement - deobfuscate exception values
-        #
-        # Exception values may contain obfuscated symbols in patterns like:
-        # - "Instance of 'obfuscated_symbol'"
-        # - General text containing obfuscated symbols
-        # This could be implemented by extracting symbols from these patterns
-        # and looking them up in the symbol map for replacement.
+            if isinstance(exception_type, str):
+                mapped_type = symbol_map.get(exception_type)
+                if mapped_type is not None:
+                    exception["type"] = mapped_type
+
+            # Deobfuscate occurrences of "Instance of 'xYz'" in the exception value
+            exception_value = exception.get("value")
+            if isinstance(exception_value, str):
+
+                def replace_symbol(match: re.Match[str]) -> str:
+                    symbol = match.group(1)
+                    deobfuscated_symbol = symbol_map.get(symbol)
+                    if deobfuscated_symbol is None:
+                        return match.group(0)
+                    return f"Instance of '{deobfuscated_symbol}'"
+
+                new_value = re.sub(INSTANCE_OF_VALUE_RE, replace_symbol, exception_value)
+                if new_value != exception_value:
+                    exception["value"] = new_value
 
 
 # TODO(buenaflor): Add this back in when we decide to deobfuscate view hierarchies

tests/sentry/lang/dart/test_plugin_deobfuscation.py

@@ -89,9 +89,11 @@ def test_dart_exception_deobfuscation_direct(self) -> None:
         preprocessor = preprocessors[0]
         preprocessor(data)
 
-        # Verify the exception type was deobfuscated, value remains unchanged
+        # Verify the exception type and value were deobfuscated
         assert data["exception"]["values"][0]["type"] == "NetworkException"
-        assert data["exception"]["values"][0]["value"] == "Instance of 'xyz' was thrown"
+        assert (
+            data["exception"]["values"][0]["value"] == "Instance of 'NetworkException' was thrown"
+        )
 
     def test_dart_multiple_exceptions_deobfuscation_direct(self) -> None:
         """Test that multiple Dart exceptions are deobfuscated."""

tests/sentry/lang/dart/test_utils.py

@@ -412,28 +412,29 @@ def test_deobfuscate_exception_type_instance_of_pattern() -> None:
     ):
         deobfuscate_exception_type(data)
 
-        # Only exception types should be deobfuscated, values remain unchanged
+        # Exception types should be deobfuscated
         assert data["exception"]["values"][0]["type"] == "NetworkException"
-        assert data["exception"]["values"][0]["value"] == "Instance of 'xyz'"
+        # Value starts with pattern: quoted symbol should be deobfuscated
+        assert data["exception"]["values"][0]["value"] == "Instance of 'NetworkException'"
 
         assert data["exception"]["values"][1]["type"] == "DatabaseException"
+        # Pattern can appear anywhere: deobfuscate occurrences
         assert (
             data["exception"]["values"][1]["value"]
-            == "Unhandled Exception: Instance of 'abc' was thrown"
+            == "Unhandled Exception: Instance of 'DatabaseException' was thrown"
         )
 
         assert data["exception"]["values"][2]["type"] == "FileException"
-        # No 'Instance of' pattern, so value should remain unchanged
+        # No pattern, value should remain unchanged
         assert (
             data["exception"]["values"][2]["value"]
             == "Error: def occurred outside of Instance pattern"
         )
 
         assert data["exception"]["values"][3]["type"] == "IOException"
-        # Values remain unchanged
         assert (
             data["exception"]["values"][3]["value"]
-            == "Instance of 'xyz' and Instance of 'ghi' both occurred"
+            == "Instance of 'NetworkException' and Instance of 'IOException' both occurred"
         )
 
 
@@ -480,21 +481,66 @@ def test_deobfuscate_exception_type_special_regex_chars() -> None:
     ):
         deobfuscate_exception_type(data)
 
-        # Exception types deobfuscated, values remain unchanged
+        # Exception types deobfuscated; values with the pattern are updated
         assert data["exception"]["values"][0]["type"] == "NetworkException"
-        assert data["exception"]["values"][0]["value"] == "Instance of 'a.b'"
+        assert data["exception"]["values"][0]["value"] == "Instance of 'NetworkException'"
 
         assert data["exception"]["values"][1]["type"] == "MathException"
-        assert data["exception"]["values"][1]["value"] == "Instance of 'x+y' occurred"
+        assert data["exception"]["values"][1]["value"] == "Instance of 'MathException' occurred"
 
         assert data["exception"]["values"][2]["type"] == "ArrayException"
-        # Values remain unchanged
         assert (
             data["exception"]["values"][2]["value"]
-            == "Instance of 'test[0]' and Instance of 'other' patterns"
+            == "Instance of 'ArrayException' and Instance of 'other' patterns"
         )
 
 
+def test_deobfuscate_exception_value_without_type() -> None:
+    """Values should be deobfuscated even if the exception type is missing or None."""
+    mock_project = mock.Mock(id=123)
+
+    data: dict[str, Any] = {
+        "project": 123,
+        "debug_meta": {"images": [{"debug_id": "test-debug-id"}]},
+        "exception": {
+            "values": [
+                {"type": None, "value": "Instance of 'xyz'"},
+                {"value": "Unhandled Exception: Instance of 'xyz' was thrown"},
+                {"type": None, "value": "No pattern here"},
+            ]
+        },
+    }
+
+    mock_map = {"xyz": "NetworkException"}
+
+    with (
+        mock.patch(
+            "sentry.models.Project.objects.get_from_cache",
+            return_value=mock_project,
+        ),
+        mock.patch(
+            "sentry.lang.dart.utils.generate_dart_symbols_map",
+            return_value=mock_map,
+        ),
+    ):
+        deobfuscate_exception_type(data)
+
+        # First: type is None, value should be deobfuscated, type remains None
+        assert data["exception"]["values"][0]["type"] is None
+        assert data["exception"]["values"][0]["value"] == "Instance of 'NetworkException'"
+
+        # Second: type key missing, value should be deobfuscated
+        assert (
+            data["exception"]["values"][1]["value"]
+            == "Unhandled Exception: Instance of 'NetworkException' was thrown"
+        )
+        assert "type" not in data["exception"]["values"][1]
+
+        # Third: no pattern; unchanged
+        assert data["exception"]["values"][2]["type"] is None
+        assert data["exception"]["values"][2]["value"] == "No pattern here"
+
+
 # @mock.patch("sentry.lang.dart.utils.generate_dart_symbols_map", return_value=MOCK_DEBUG_MAP)
 # @mock.patch("sentry.lang.dart.utils.get_debug_meta_image_ids", return_value=["test-uuid"])
 # def test_view_hierarchy_deobfuscation(