Remove databag trimming

Author: sentrivana

sentry_sdk/integrations/pure_eval.py

@@ -128,8 +128,5 @@ def start(n: ast.expr) -> Tuple[int, int]:
     atok = source.asttokens()
 
     expressions.sort(key=closeness, reverse=True)
-    vars = {
-        atok.get_text(nodes[0]): value
-        for nodes, value in expressions[: serializer.MAX_DATABAG_BREADTH]
-    }
+    vars = {atok.get_text(nodes[0]): value for nodes, value in expressions}
     return serializer.serialize(vars, is_vars=True)

sentry_sdk/serializer.py

@@ -38,11 +38,6 @@
 # Bytes are technically not strings in Python 3, but we can serialize them
 serializable_str_types = (str, bytes, bytearray, memoryview)
 
-
-# Maximum depth and breadth of databags. Excess data will be trimmed. If
-# max_request_body_size is "always", request bodies won't be trimmed.
-MAX_DATABAG_DEPTH = 5
-MAX_DATABAG_BREADTH = 10
 CYCLE_MARKER = "<cyclic>"
 
 
@@ -99,7 +94,6 @@ def serialize(event: Union[Dict[str, Any], Event], **kwargs: Any) -> Dict[str, A
     The algorithm itself is a recursive graph walk down the data structures it encounters.
 
     It has the following responsibilities:
-    * Trimming databags and keeping them within MAX_DATABAG_BREADTH and MAX_DATABAG_DEPTH.
     * Calling safe_repr() on objects appropriately to keep them informative and readable in the final payload.
     * Annotating the payload with the _meta field whenever trimming happens.
 
@@ -113,7 +107,6 @@ def serialize(event: Union[Dict[str, Any], Event], **kwargs: Any) -> Dict[str, A
     path: List[Segment] = []
     meta_stack: List[Dict[str, Any]] = []
 
-    keep_request_bodies: bool = kwargs.pop("max_request_body_size", None) == "always"
     max_value_length: Optional[int] = kwargs.pop("max_value_length", None)
     is_vars = kwargs.pop("is_vars", False)
     custom_repr: Callable[..., Optional[str]] = kwargs.pop("custom_repr", None)
@@ -179,11 +172,8 @@ def _is_request_body() -> Optional[bool]:
     def _serialize_node(
         obj: Any,
         is_databag: Optional[bool] = None,
-        is_request_body: Optional[bool] = None,
         should_repr_strings: Optional[bool] = None,
         segment: Optional[Segment] = None,
-        remaining_breadth: Optional[Union[int, float]] = None,
-        remaining_depth: Optional[Union[int, float]] = None,
     ) -> Any:
         if segment is not None:
             path.append(segment)
@@ -196,10 +186,7 @@ def _serialize_node(
                 return _serialize_node_impl(
                     obj,
                     is_databag=is_databag,
-                    is_request_body=is_request_body,
                     should_repr_strings=should_repr_strings,
-                    remaining_depth=remaining_depth,
-                    remaining_breadth=remaining_breadth,
                 )
         except BaseException:
             capture_internal_exception(sys.exc_info())
@@ -222,10 +209,7 @@ def _flatten_annotated(obj: Any) -> Any:
     def _serialize_node_impl(
         obj: Any,
         is_databag: Optional[bool],
-        is_request_body: Optional[bool],
         should_repr_strings: Optional[bool],
-        remaining_depth: Optional[Union[float, int]],
-        remaining_breadth: Optional[Union[float, int]],
     ) -> Any:
         if isinstance(obj, AnnotatedValue):
             should_repr_strings = False
@@ -235,31 +219,10 @@ def _serialize_node_impl(
         if is_databag is None:
             is_databag = _is_databag()
 
-        if is_request_body is None:
-            is_request_body = _is_request_body()
-
-        if is_databag:
-            if is_request_body and keep_request_bodies:
-                remaining_depth = float("inf")
-                remaining_breadth = float("inf")
-            else:
-                if remaining_depth is None:
-                    remaining_depth = MAX_DATABAG_DEPTH
-                if remaining_breadth is None:
-                    remaining_breadth = MAX_DATABAG_BREADTH
-
         obj = _flatten_annotated(obj)
 
-        if remaining_depth is not None and remaining_depth <= 0:
-            _annotate(rem=[["!limit", "x"]])
-            if is_databag:
-                return _flatten_annotated(
-                    strip_string(_safe_repr_wrapper(obj), max_length=max_value_length)
-                )
-            return None
-
         if is_databag and global_repr_processors:
-            hints = {"memo": memo, "remaining_depth": remaining_depth}
+            hints = {"memo": memo}
             for processor in global_repr_processors:
                 result = processor(obj, hints)
                 if result is not NotImplemented:
@@ -294,21 +257,12 @@ def _serialize_node_impl(
             i = 0
 
             for k, v in obj.items():
-                if remaining_breadth is not None and i >= remaining_breadth:
-                    _annotate(len=len(obj))
-                    break
-
                 str_k = str(k)
                 v = _serialize_node(
                     v,
                     segment=str_k,
                     should_repr_strings=should_repr_strings,
                     is_databag=is_databag,
-                    is_request_body=is_request_body,
-                    remaining_depth=(
-                        remaining_depth - 1 if remaining_depth is not None else None
-                    ),
-                    remaining_breadth=remaining_breadth,
                 )
                 rv_dict[str_k] = v
                 i += 1
@@ -321,21 +275,12 @@ def _serialize_node_impl(
             rv_list = []
 
             for i, v in enumerate(obj):
-                if remaining_breadth is not None and i >= remaining_breadth:
-                    _annotate(len=len(obj))
-                    break
-
                 rv_list.append(
                     _serialize_node(
                         v,
                         segment=i,
                         should_repr_strings=should_repr_strings,
                         is_databag=is_databag,
-                        is_request_body=is_request_body,
-                        remaining_depth=(
-                            remaining_depth - 1 if remaining_depth is not None else None
-                        ),
-                        remaining_breadth=remaining_breadth,
                     )
                 )
 

tests/test_client.py

@@ -24,7 +24,6 @@
 from sentry_sdk.utils import capture_internal_exception
 from sentry_sdk.integrations.executing import ExecutingIntegration
 from sentry_sdk.transport import Transport
-from sentry_sdk.serializer import MAX_DATABAG_BREADTH
 from sentry_sdk.consts import DEFAULT_MAX_BREADCRUMBS, DEFAULT_MAX_VALUE_LENGTH
 
 from typing import TYPE_CHECKING
@@ -726,7 +725,7 @@ def inner():
         assert len(json.dumps(event)) < DEFAULT_MAX_VALUE_LENGTH * 10
 
 
-def test_databag_breadth_stripping(sentry_init, capture_events, benchmark):
+def test_databag_breadth_no_stripping(sentry_init, capture_events, benchmark):
     sentry_init()
     events = capture_events()
 
@@ -743,9 +742,8 @@ def inner():
 
         assert (
             len(event["exception"]["values"][0]["stacktrace"]["frames"][0]["vars"]["a"])
-            == MAX_DATABAG_BREADTH
+            == 1000000
         )
-        assert len(json.dumps(event)) < 10000
 
 
 def test_chained_exceptions(sentry_init, capture_events):

tests/test_serializer.py

@@ -3,7 +3,7 @@
 import pytest
 
 from sentry_sdk.consts import DEFAULT_MAX_VALUE_LENGTH
-from sentry_sdk.serializer import MAX_DATABAG_BREADTH, MAX_DATABAG_DEPTH, serialize
+from sentry_sdk.serializer import serialize
 
 try:
     from hypothesis import given
@@ -140,32 +140,16 @@ def custom_repr(value):
     assert "Foo object" in result["foo"]
 
 
-def test_trim_databag_breadth(body_normalizer):
-    data = {
-        "key{}".format(i): "value{}".format(i) for i in range(MAX_DATABAG_BREADTH + 10)
-    }
+def test_dont_trim_databag_breadth(body_normalizer):
+    data = {"key{}".format(i): "value{}".format(i) for i in range(10**9)}
 
     result = body_normalizer(data)
 
-    assert len(result) == MAX_DATABAG_BREADTH
+    assert len(result) == 10**9
     for key, value in result.items():
         assert data.get(key) == value
 
 
-def test_no_trimming_if_max_request_body_size_is_always(body_normalizer):
-    data = {
-        "key{}".format(i): "value{}".format(i) for i in range(MAX_DATABAG_BREADTH + 10)
-    }
-    curr = data
-    for _ in range(MAX_DATABAG_DEPTH + 5):
-        curr["nested"] = {}
-        curr = curr["nested"]
-
-    result = body_normalizer(data, max_request_body_size="always")
-
-    assert result == data
-
-
 def test_max_value_length_default(body_normalizer):
     data = {"key": "a" * (DEFAULT_MAX_VALUE_LENGTH * 10)}