replace max_request_body_size with include_request_bodies

Author: sentrivana

sentry_sdk/_types.py

@@ -57,8 +57,7 @@ def removed_because_raw_data(cls) -> AnnotatedValue:
     @classmethod
     def removed_because_over_size_limit(cls, value: Any = "") -> AnnotatedValue:
         """
-        The actual value was removed because the size of the field exceeded the configured maximum size,
-        for example specified with the max_request_body_size sdk option.
+        The actual value was removed because the size of the field exceeded the configured maximum size.
         """
         return AnnotatedValue(
             value=value,

sentry_sdk/client.py

@@ -329,14 +329,6 @@ def _capture_envelope(envelope: Envelope) -> None:
 
                 self.log_batcher = LogBatcher(capture_func=_capture_envelope)
 
-            max_request_body_size = ("always", "never", "small", "medium")
-            if self.options["max_request_body_size"] not in max_request_body_size:
-                raise ValueError(
-                    "Invalid value for max_request_body_size. Must be one of {}".format(
-                        max_request_body_size
-                    )
-                )
-
             self.integrations = setup_integrations(
                 self.options["integrations"],
                 with_defaults=self.options["default_integrations"],
@@ -547,7 +539,6 @@ def _prepare_event(
         if event is not None:
             event: Event = serialize(  # type: ignore[no-redef]
                 event,
-                max_request_body_size=self.options.get("max_request_body_size"),
                 max_value_length=self.options.get("max_value_length"),
                 custom_repr=self.options.get("custom_repr"),
             )

sentry_sdk/consts.py

@@ -812,7 +812,7 @@ def __init__(
         http_proxy: Optional[str] = None,
         https_proxy: Optional[str] = None,
         ignore_errors: Sequence[Union[type, str]] = [],  # noqa: B006
-        max_request_body_size: str = "medium",
+        inclue_request_bodies: Optional[bool] = True,
         socket_options: Optional[List[Tuple[int, int, int | bytes]]] = None,
         keep_alive: Optional[bool] = None,
         before_send: Optional[EventProcessor] = None,
@@ -1006,18 +1006,8 @@ def __init__(
 
             This option can be overridden using `in_app_include`.
 
-        :param max_request_body_size: This parameter controls whether integrations should capture HTTP request bodies.
-            It can be set to one of the following values:
-
-            - `never`: Request bodies are never sent.
-            - `small`: Only small request bodies will be captured. The cutoff for small depends on the SDK (typically
-              4KB).
-            - `medium`: Medium and small requests will be captured (typically 10KB).
-            - `always`: The SDK will always capture the request body as long as Sentry can make sense of it.
-
-            Please note that the Sentry server [limits HTTP request body size](https://develop.sentry.dev/sdk/
-            expected-features/data-handling/#variable-size). The server always enforces its size limit, regardless of
-            how you configure this option.
+        :param include_request_bodies: This parameter controls whether integrations should capture HTTP request bodies.
+            If set to False, request bodies will not be captured. By default, request bodies will be included.
 
         :param max_value_length: The number of characters after which the values containing text in the event payload
             will be truncated.

sentry_sdk/integrations/_wsgi_common.py

@@ -51,18 +51,13 @@
 )
 
 
-def request_body_within_bounds(
+def should_include_request_body(
     client: Optional[sentry_sdk.client.BaseClient], content_length: int
 ) -> bool:
     if client is None:
         return False
 
-    bodies = client.options["max_request_body_size"]
-    return not (
-        bodies == "never"
-        or (bodies == "small" and content_length > 10**3)
-        or (bodies == "medium" and content_length > 10**4)
-    )
+    return client.options.get("include_request_bodies") in (True, None)
 
 
 class RequestExtractor:
@@ -91,7 +86,7 @@ def extract_into_event(self, event: Event) -> None:
         if should_send_default_pii():
             request_info["cookies"] = dict(self.cookies())
 
-        if not request_body_within_bounds(client, content_length):
+        if not should_include_request_body(client, content_length):
             data = AnnotatedValue.removed_because_over_size_limit()
         else:
             # First read the raw body data

sentry_sdk/integrations/aiohttp.py

@@ -23,7 +23,7 @@
 from sentry_sdk.integrations._wsgi_common import (
     _filter_headers,
     _request_headers_to_span_attributes,
-    request_body_within_bounds,
+    should_include_request_body,
 )
 from sentry_sdk.tracing_utils import should_propagate_trace
 from sentry_sdk.utils import (
@@ -366,7 +366,7 @@ def get_aiohttp_request_data(request: Request) -> Union[Optional[str], Annotated
 
     if bytes_body is not None:
         # we have body to show
-        if not request_body_within_bounds(sentry_sdk.get_client(), len(bytes_body)):
+        if not should_include_request_body(sentry_sdk.get_client(), len(bytes_body)):
             return AnnotatedValue.removed_because_over_size_limit()
 
         encoding = request.charset or "utf-8"

sentry_sdk/integrations/ariadne.py

@@ -5,7 +5,7 @@
 from sentry_sdk import get_client, capture_event
 from sentry_sdk.integrations import _check_minimum_version, DidNotEnable, Integration
 from sentry_sdk.integrations.logging import ignore_logger
-from sentry_sdk.integrations._wsgi_common import request_body_within_bounds
+from sentry_sdk.integrations._wsgi_common import should_include_request_body
 from sentry_sdk.scope import should_send_default_pii
 from sentry_sdk.utils import (
     capture_internal_exceptions,
@@ -128,7 +128,7 @@ def inner(event: Event, hint: dict[str, Any]) -> Event:
             except (TypeError, ValueError):
                 return event
 
-            if should_send_default_pii() and request_body_within_bounds(
+            if should_send_default_pii() and should_include_request_body(
                 get_client(), content_length
             ):
                 request_info = event.setdefault("request", {})

sentry_sdk/integrations/dramatiq.py

@@ -3,7 +3,7 @@
 
 import sentry_sdk
 from sentry_sdk.integrations import Integration
-from sentry_sdk.integrations._wsgi_common import request_body_within_bounds
+from sentry_sdk.integrations._wsgi_common import should_include_request_body
 from sentry_sdk.utils import (
     AnnotatedValue,
     capture_internal_exceptions,
@@ -160,7 +160,7 @@ def extract_into_event(self, event: Event) -> None:
         request_info["type"] = "dramatiq"
 
         data: Optional[Union[AnnotatedValue, Dict[str, Any]]] = None
-        if not request_body_within_bounds(client, self.content_length()):
+        if not should_include_request_body(client, self.content_length()):
             data = AnnotatedValue.removed_because_over_size_limit()
         else:
             data = self.message_data

sentry_sdk/integrations/starlette.py

@@ -15,7 +15,7 @@
 from sentry_sdk.integrations._wsgi_common import (
     DEFAULT_HTTP_METHODS_TO_CAPTURE,
     _is_json_content_type,
-    request_body_within_bounds,
+    should_include_request_body,
 )
 from sentry_sdk.integrations.asgi import SentryAsgiMiddleware
 from sentry_sdk.scope import should_send_default_pii
@@ -598,7 +598,7 @@ async def extract_request_info(
                 return request_info
 
             # Add annotation if body is too big
-            if content_length and not request_body_within_bounds(
+            if content_length and not should_include_request_body(
                 client, content_length
             ):
                 request_info["data"] = AnnotatedValue.removed_because_over_size_limit()

sentry_sdk/serializer.py

@@ -97,7 +97,6 @@ def serialize(event: Union[Dict[str, Any], Event], **kwargs: Any) -> Dict[str, A
     * 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.
 
-    :param max_request_body_size: If set to "always", will never trim request bodies.
     :param max_value_length: The max length to strip strings to, defaults to sentry_sdk.consts.DEFAULT_MAX_VALUE_LENGTH
     :param is_vars: If we're serializing vars early, we want to repr() things that are JSON-serializable to make their type more apparent. For example, it's useful to see the difference between a unicode-string and a bytestring when viewing a stacktrace.
     :param custom_repr: A custom repr function that runs before safe_repr on the object to be serialized. If it returns None or throws internally, we will fallback to safe_repr.

tests/integrations/bottle/test_bottle.py

@@ -122,7 +122,7 @@ def index():
 
 
 def test_large_json_request(sentry_init, capture_events, app, get_client):
-    sentry_init(integrations=[BottleIntegration()], max_request_body_size="always")
+    sentry_init(integrations=[BottleIntegration()])
 
     data = {"foo": {"bar": "a" * (DEFAULT_MAX_VALUE_LENGTH + 10)}}
 
@@ -180,7 +180,7 @@ def index():
 
 
 def test_medium_formdata_request(sentry_init, capture_events, app, get_client):
-    sentry_init(integrations=[BottleIntegration()], max_request_body_size="always")
+    sentry_init(integrations=[BottleIntegration()])
 
     data = {"foo": "a" * (DEFAULT_MAX_VALUE_LENGTH + 10)}
 
@@ -210,39 +210,8 @@ def index():
     assert len(event["request"]["data"]["foo"]) == DEFAULT_MAX_VALUE_LENGTH
 
 
-@pytest.mark.parametrize("input_char", ["a", b"a"])
-def test_too_large_raw_request(
-    sentry_init, input_char, capture_events, app, get_client
-):
-    sentry_init(integrations=[BottleIntegration()], max_request_body_size="small")
-
-    data = input_char * 2000
-
-    @app.route("/", method="POST")
-    def index():
-        import bottle
-
-        if isinstance(data, bytes):
-            assert bottle.request.body.read() == data
-        else:
-            assert bottle.request.body.read() == data.encode("ascii")
-        assert not bottle.request.json
-        capture_message("hi")
-        return "ok"
-
-    events = capture_events()
-
-    client = get_client()
-    response = client.post("/", data=data)
-    assert response[1] == "200 OK"
-
-    (event,) = events
-    assert event["_meta"]["request"]["data"] == {"": {"rem": [["!config", "x"]]}}
-    assert not event["request"]["data"]
-
-
 def test_files_and_form(sentry_init, capture_events, app, get_client):
-    sentry_init(integrations=[BottleIntegration()], max_request_body_size="always")
+    sentry_init(integrations=[BottleIntegration()])
 
     data = {
         "foo": "a" * (DEFAULT_MAX_VALUE_LENGTH + 10),
@@ -284,10 +253,8 @@ def index():
     assert not event["request"]["data"]["file"]
 
 
-def test_json_not_truncated_if_max_request_body_size_is_always(
-    sentry_init, capture_events, app, get_client
-):
-    sentry_init(integrations=[BottleIntegration()], max_request_body_size="always")
+def test_json_not_truncated(sentry_init, capture_events, app, get_client):
+    sentry_init(integrations=[BottleIntegration()])
 
     data = {
         "key{}".format(i): "value{}".format(i) for i in range(MAX_DATABAG_BREADTH + 10)