diff --git a/sentry_sdk/client.py b/sentry_sdk/client.py index 2c245297bd..9e667bc5cb 100644 --- a/sentry_sdk/client.py +++ b/sentry_sdk/client.py @@ -34,7 +34,6 @@ from sentry_sdk.transport import BaseHttpTransport, make_transport from sentry_sdk.consts import ( SPANDATA, - DEFAULT_MAX_VALUE_LENGTH, DEFAULT_OPTIONS, INSTRUMENTER, VERSION, @@ -584,7 +583,7 @@ def _prepare_event( "include_local_variables", True ), max_value_length=self.options.get( - "max_value_length", DEFAULT_MAX_VALUE_LENGTH + "max_value_length", None ), ), "crashed": False, diff --git a/sentry_sdk/consts.py b/sentry_sdk/consts.py index f74ea4eba4..b462ee2c14 100644 --- a/sentry_sdk/consts.py +++ b/sentry_sdk/consts.py @@ -2,12 +2,6 @@ from enum import Enum from typing import TYPE_CHECKING -# up top to prevent circular import due to integration import -# This is more or less an arbitrary large-ish value for now, so that we allow -# pretty long strings (like LLM prompts), but still have *some* upper limit -# until we verify that removing the trimming completely is safe. -DEFAULT_MAX_VALUE_LENGTH = 100_000 - DEFAULT_MAX_STACK_FRAMES = 100 DEFAULT_ADD_FULL_STACK = False @@ -996,7 +990,7 @@ def __init__( ], # type: Optional[Sequence[str]] functions_to_trace=[], # type: Sequence[Dict[str, str]] # noqa: B006 event_scrubber=None, # type: Optional[sentry_sdk.scrubber.EventScrubber] - max_value_length=DEFAULT_MAX_VALUE_LENGTH, # type: int + max_value_length=None, # type: Optional[int] enable_backpressure_handling=True, # type: bool error_sampler=None, # type: Optional[Callable[[Event, Hint], Union[float, bool]]] enable_db_query_source=True, # type: bool diff --git a/sentry_sdk/serializer.py b/sentry_sdk/serializer.py index 1775b1b555..a98d4cc552 100644 --- a/sentry_sdk/serializer.py +++ b/sentry_sdk/serializer.py @@ -119,7 +119,7 @@ def serialize(event, **kwargs): * 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 max_value_length: The max length to strip strings to, or None to disable string truncation. Defaults to None. :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. diff --git a/sentry_sdk/utils.py b/sentry_sdk/utils.py index eae6156b13..8cba748c94 100644 --- a/sentry_sdk/utils.py +++ b/sentry_sdk/utils.py @@ -29,7 +29,6 @@ from sentry_sdk.consts import ( DEFAULT_ADD_FULL_STACK, DEFAULT_MAX_STACK_FRAMES, - DEFAULT_MAX_VALUE_LENGTH, EndpointType, ) from sentry_sdk._types import Annotated, AnnotatedValue, SENSITIVE_DATA_SUBSTITUTE @@ -730,7 +729,7 @@ def single_exception_from_error_tuple( if client_options is None: include_local_variables = True include_source_context = True - max_value_length = DEFAULT_MAX_VALUE_LENGTH # fallback + max_value_length = None # fallback custom_repr = None else: include_local_variables = client_options["include_local_variables"] @@ -1211,7 +1210,7 @@ def strip_string(value, max_length=None): return value if max_length is None: - max_length = DEFAULT_MAX_VALUE_LENGTH + return value byte_size = _get_size_in_bytes(value) text_size = len(value) diff --git a/tests/integrations/bottle/test_bottle.py b/tests/integrations/bottle/test_bottle.py index 1965691d6c..2db59299be 100644 --- a/tests/integrations/bottle/test_bottle.py +++ b/tests/integrations/bottle/test_bottle.py @@ -5,7 +5,6 @@ from io import BytesIO from bottle import Bottle, debug as set_debug, abort, redirect, HTTPResponse from sentry_sdk import capture_message -from sentry_sdk.consts import DEFAULT_MAX_VALUE_LENGTH from sentry_sdk.integrations.bottle import BottleIntegration from sentry_sdk.serializer import MAX_DATABAG_BREADTH @@ -121,10 +120,17 @@ def index(): assert event["exception"]["values"][0]["mechanism"]["handled"] is False -def test_large_json_request(sentry_init, capture_events, app, get_client): - sentry_init(integrations=[BottleIntegration()], max_request_body_size="always") +@pytest.mark.parametrize("max_value_length", [1024, None]) +def test_large_json_request( + sentry_init, capture_events, app, get_client, max_value_length +): + sentry_init( + integrations=[BottleIntegration()], + max_request_body_size="always", + max_value_length=max_value_length, + ) - data = {"foo": {"bar": "a" * (DEFAULT_MAX_VALUE_LENGTH + 10)}} + data = {"foo": {"bar": "a" * (1034)}} @app.route("/", method="POST") def index(): @@ -144,15 +150,17 @@ def index(): assert response[1] == "200 OK" (event,) = events - assert event["_meta"]["request"]["data"]["foo"]["bar"] == { - "": { - "len": DEFAULT_MAX_VALUE_LENGTH + 10, - "rem": [ - ["!limit", "x", DEFAULT_MAX_VALUE_LENGTH - 3, DEFAULT_MAX_VALUE_LENGTH] - ], + + if max_value_length: + assert event["_meta"]["request"]["data"]["foo"]["bar"] == { + "": { + "len": 1034, + "rem": [["!limit", "x", 1021, 1024]], + } } - } - assert len(event["request"]["data"]["foo"]["bar"]) == DEFAULT_MAX_VALUE_LENGTH + assert len(event["request"]["data"]["foo"]["bar"]) == 1024 + else: + assert len(event["request"]["data"]["foo"]["bar"]) == 1034 @pytest.mark.parametrize("data", [{}, []], ids=["empty-dict", "empty-list"]) @@ -179,10 +187,17 @@ def index(): assert event["request"]["data"] == data -def test_medium_formdata_request(sentry_init, capture_events, app, get_client): - sentry_init(integrations=[BottleIntegration()], max_request_body_size="always") +@pytest.mark.parametrize("max_value_length", [1024, None]) +def test_medium_formdata_request( + sentry_init, capture_events, app, get_client, max_value_length +): + sentry_init( + integrations=[BottleIntegration()], + max_request_body_size="always", + max_value_length=max_value_length, + ) - data = {"foo": "a" * (DEFAULT_MAX_VALUE_LENGTH + 10)} + data = {"foo": "a" * (1034)} @app.route("/", method="POST") def index(): @@ -199,15 +214,17 @@ def index(): assert response[1] == "200 OK" (event,) = events - assert event["_meta"]["request"]["data"]["foo"] == { - "": { - "len": DEFAULT_MAX_VALUE_LENGTH + 10, - "rem": [ - ["!limit", "x", DEFAULT_MAX_VALUE_LENGTH - 3, DEFAULT_MAX_VALUE_LENGTH] - ], + + if max_value_length: + assert event["_meta"]["request"]["data"]["foo"] == { + "": { + "len": 1034, + "rem": [["!limit", "x", 1021, 1024]], + } } - } - assert len(event["request"]["data"]["foo"]) == DEFAULT_MAX_VALUE_LENGTH + assert len(event["request"]["data"]["foo"]) == 1024 + else: + assert len(event["request"]["data"]["foo"]) == 1034 @pytest.mark.parametrize("input_char", ["a", b"a"]) @@ -241,11 +258,16 @@ def index(): 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") +@pytest.mark.parametrize("max_value_length", [1024, None]) +def test_files_and_form(sentry_init, capture_events, app, get_client, max_value_length): + sentry_init( + integrations=[BottleIntegration()], + max_request_body_size="always", + max_value_length=max_value_length, + ) data = { - "foo": "a" * (DEFAULT_MAX_VALUE_LENGTH + 10), + "foo": "a" * (1034), "file": (BytesIO(b"hello"), "hello.txt"), } @@ -266,15 +288,16 @@ def index(): assert response[1] == "200 OK" (event,) = events - assert event["_meta"]["request"]["data"]["foo"] == { - "": { - "len": DEFAULT_MAX_VALUE_LENGTH + 10, - "rem": [ - ["!limit", "x", DEFAULT_MAX_VALUE_LENGTH - 3, DEFAULT_MAX_VALUE_LENGTH] - ], + if max_value_length: + assert event["_meta"]["request"]["data"]["foo"] == { + "": { + "len": 1034, + "rem": [["!limit", "x", 1021, 1024]], + } } - } - assert len(event["request"]["data"]["foo"]) == DEFAULT_MAX_VALUE_LENGTH + assert len(event["request"]["data"]["foo"]) == 1024 + else: + assert len(event["request"]["data"]["foo"]) == 1034 assert event["_meta"]["request"]["data"]["file"] == { "": { diff --git a/tests/integrations/falcon/test_falcon.py b/tests/integrations/falcon/test_falcon.py index f972419092..e26b3c7785 100644 --- a/tests/integrations/falcon/test_falcon.py +++ b/tests/integrations/falcon/test_falcon.py @@ -5,7 +5,6 @@ import falcon import falcon.testing import sentry_sdk -from sentry_sdk.consts import DEFAULT_MAX_VALUE_LENGTH from sentry_sdk.integrations.falcon import FalconIntegration from sentry_sdk.integrations.logging import LoggingIntegration from sentry_sdk.utils import parse_version @@ -207,10 +206,15 @@ def on_get(self, req, resp): assert len(events) == 0 -def test_falcon_large_json_request(sentry_init, capture_events): - sentry_init(integrations=[FalconIntegration()], max_request_body_size="always") +@pytest.mark.parametrize("max_value_length", [1024, None]) +def test_falcon_large_json_request(sentry_init, capture_events, max_value_length): + sentry_init( + integrations=[FalconIntegration()], + max_request_body_size="always", + max_value_length=max_value_length, + ) - data = {"foo": {"bar": "a" * (DEFAULT_MAX_VALUE_LENGTH + 10)}} + data = {"foo": {"bar": "a" * (1034)}} class Resource: def on_post(self, req, resp): @@ -228,15 +232,16 @@ def on_post(self, req, resp): assert response.status == falcon.HTTP_200 (event,) = events - assert event["_meta"]["request"]["data"]["foo"]["bar"] == { - "": { - "len": DEFAULT_MAX_VALUE_LENGTH + 10, - "rem": [ - ["!limit", "x", DEFAULT_MAX_VALUE_LENGTH - 3, DEFAULT_MAX_VALUE_LENGTH] - ], + if max_value_length: + assert event["_meta"]["request"]["data"]["foo"]["bar"] == { + "": { + "len": 1034, + "rem": [["!limit", "x", 1021, 1024]], + } } - } - assert len(event["request"]["data"]["foo"]["bar"]) == DEFAULT_MAX_VALUE_LENGTH + assert len(event["request"]["data"]["foo"]["bar"]) == 1024 + else: + assert len(event["request"]["data"]["foo"]["bar"]) == 1034 @pytest.mark.parametrize("data", [{}, []], ids=["empty-dict", "empty-list"]) diff --git a/tests/integrations/flask/test_flask.py b/tests/integrations/flask/test_flask.py index e117b98ca9..d037e46e67 100644 --- a/tests/integrations/flask/test_flask.py +++ b/tests/integrations/flask/test_flask.py @@ -27,7 +27,6 @@ capture_message, capture_exception, ) -from sentry_sdk.consts import DEFAULT_MAX_VALUE_LENGTH from sentry_sdk.integrations.logging import LoggingIntegration from sentry_sdk.serializer import MAX_DATABAG_BREADTH @@ -248,12 +247,15 @@ def login(): assert event["user"]["id"] == str(user_id) -def test_flask_large_json_request(sentry_init, capture_events, app): +@pytest.mark.parametrize("max_value_length", [1024, None]) +def test_flask_large_json_request(sentry_init, capture_events, app, max_value_length): sentry_init( - integrations=[flask_sentry.FlaskIntegration()], max_request_body_size="always" + integrations=[flask_sentry.FlaskIntegration()], + max_request_body_size="always", + max_value_length=max_value_length, ) - data = {"foo": {"bar": "a" * (DEFAULT_MAX_VALUE_LENGTH + 10)}} + data = {"foo": {"bar": "a" * (1034)}} @app.route("/", methods=["POST"]) def index(): @@ -270,15 +272,16 @@ def index(): assert response.status_code == 200 (event,) = events - assert event["_meta"]["request"]["data"]["foo"]["bar"] == { - "": { - "len": DEFAULT_MAX_VALUE_LENGTH + 10, - "rem": [ - ["!limit", "x", DEFAULT_MAX_VALUE_LENGTH - 3, DEFAULT_MAX_VALUE_LENGTH] - ], + if max_value_length: + assert event["_meta"]["request"]["data"]["foo"]["bar"] == { + "": { + "len": 1034, + "rem": [["!limit", "x", 1021, 1024]], + } } - } - assert len(event["request"]["data"]["foo"]["bar"]) == DEFAULT_MAX_VALUE_LENGTH + assert len(event["request"]["data"]["foo"]["bar"]) == 1024 + else: + assert len(event["request"]["data"]["foo"]["bar"]) == 1034 def test_flask_session_tracking(sentry_init, capture_envelopes, app): @@ -343,12 +346,17 @@ def index(): assert event["request"]["data"] == data -def test_flask_medium_formdata_request(sentry_init, capture_events, app): +@pytest.mark.parametrize("max_value_length", [1024, None]) +def test_flask_medium_formdata_request( + sentry_init, capture_events, app, max_value_length +): sentry_init( - integrations=[flask_sentry.FlaskIntegration()], max_request_body_size="always" + integrations=[flask_sentry.FlaskIntegration()], + max_request_body_size="always", + max_value_length=max_value_length, ) - data = {"foo": "a" * (DEFAULT_MAX_VALUE_LENGTH + 10)} + data = {"foo": "a" * (1034)} @app.route("/", methods=["POST"]) def index(): @@ -369,15 +377,16 @@ def index(): assert response.status_code == 200 (event,) = events - assert event["_meta"]["request"]["data"]["foo"] == { - "": { - "len": DEFAULT_MAX_VALUE_LENGTH + 10, - "rem": [ - ["!limit", "x", DEFAULT_MAX_VALUE_LENGTH - 3, DEFAULT_MAX_VALUE_LENGTH] - ], + if max_value_length: + assert event["_meta"]["request"]["data"]["foo"] == { + "": { + "len": 1034, + "rem": [["!limit", "x", 1021, 1024]], + } } - } - assert len(event["request"]["data"]["foo"]) == DEFAULT_MAX_VALUE_LENGTH + assert len(event["request"]["data"]["foo"]) == 1024 + else: + assert len(event["request"]["data"]["foo"]) == 1034 def test_flask_formdata_request_appear_transaction_body( @@ -451,13 +460,16 @@ def index(): assert not event["request"]["data"] -def test_flask_files_and_form(sentry_init, capture_events, app): +@pytest.mark.parametrize("max_value_length", [1024, None]) +def test_flask_files_and_form(sentry_init, capture_events, app, max_value_length): sentry_init( - integrations=[flask_sentry.FlaskIntegration()], max_request_body_size="always" + integrations=[flask_sentry.FlaskIntegration()], + max_request_body_size="always", + max_value_length=max_value_length, ) data = { - "foo": "a" * (DEFAULT_MAX_VALUE_LENGTH + 10), + "foo": "a" * (1034), "file": (BytesIO(b"hello"), "hello.txt"), } @@ -480,15 +492,16 @@ def index(): assert response.status_code == 200 (event,) = events - assert event["_meta"]["request"]["data"]["foo"] == { - "": { - "len": DEFAULT_MAX_VALUE_LENGTH + 10, - "rem": [ - ["!limit", "x", DEFAULT_MAX_VALUE_LENGTH - 3, DEFAULT_MAX_VALUE_LENGTH] - ], + if max_value_length: + assert event["_meta"]["request"]["data"]["foo"] == { + "": { + "len": 1034, + "rem": [["!limit", "x", 1021, 1024]], + } } - } - assert len(event["request"]["data"]["foo"]) == DEFAULT_MAX_VALUE_LENGTH + assert len(event["request"]["data"]["foo"]) == 1024 + else: + assert len(event["request"]["data"]["foo"]) == 1034 assert event["_meta"]["request"]["data"]["file"] == {"": {"rem": [["!raw", "x"]]}} assert not event["request"]["data"]["file"] diff --git a/tests/integrations/pyramid/test_pyramid.py b/tests/integrations/pyramid/test_pyramid.py index cd200f7f7b..24330ba97e 100644 --- a/tests/integrations/pyramid/test_pyramid.py +++ b/tests/integrations/pyramid/test_pyramid.py @@ -9,7 +9,6 @@ from werkzeug.test import Client from sentry_sdk import capture_message, add_breadcrumb -from sentry_sdk.consts import DEFAULT_MAX_VALUE_LENGTH from sentry_sdk.integrations.pyramid import PyramidIntegration from sentry_sdk.serializer import MAX_DATABAG_BREADTH from tests.conftest import unpack_werkzeug_response @@ -156,10 +155,17 @@ def test_transaction_style( assert event["transaction_info"] == {"source": expected_source} -def test_large_json_request(sentry_init, capture_events, route, get_client): - sentry_init(integrations=[PyramidIntegration()], max_request_body_size="always") +@pytest.mark.parametrize("max_value_length", [1024, None]) +def test_large_json_request( + sentry_init, capture_events, route, get_client, max_value_length +): + sentry_init( + integrations=[PyramidIntegration()], + max_request_body_size="always", + max_value_length=max_value_length, + ) - data = {"foo": {"bar": "a" * (DEFAULT_MAX_VALUE_LENGTH + 10)}} + data = {"foo": {"bar": "a" * (1034)}} @route("/") def index(request): @@ -175,15 +181,17 @@ def index(request): client.post("/", content_type="application/json", data=json.dumps(data)) (event,) = events - assert event["_meta"]["request"]["data"]["foo"]["bar"] == { - "": { - "len": DEFAULT_MAX_VALUE_LENGTH + 10, - "rem": [ - ["!limit", "x", DEFAULT_MAX_VALUE_LENGTH - 3, DEFAULT_MAX_VALUE_LENGTH] - ], + + if max_value_length: + assert event["_meta"]["request"]["data"]["foo"]["bar"] == { + "": { + "len": 1034, + "rem": [["!limit", "x", 1021, 1024]], + } } - } - assert len(event["request"]["data"]["foo"]["bar"]) == DEFAULT_MAX_VALUE_LENGTH + assert len(event["request"]["data"]["foo"]["bar"]) == 1024 + else: + assert len(event["request"]["data"]["foo"]["bar"]) == 1034 @pytest.mark.parametrize("data", [{}, []], ids=["empty-dict", "empty-list"]) @@ -233,11 +241,18 @@ def index(request): assert event["request"]["data"] == data -def test_files_and_form(sentry_init, capture_events, route, get_client): - sentry_init(integrations=[PyramidIntegration()], max_request_body_size="always") +@pytest.mark.parametrize("max_value_length", [1024, None]) +def test_files_and_form( + sentry_init, capture_events, route, get_client, max_value_length +): + sentry_init( + integrations=[PyramidIntegration()], + max_request_body_size="always", + max_value_length=max_value_length, + ) data = { - "foo": "a" * (DEFAULT_MAX_VALUE_LENGTH + 10), + "foo": "a" * (1034), "file": (BytesIO(b"hello"), "hello.txt"), } @@ -252,15 +267,16 @@ def index(request): client.post("/", data=data) (event,) = events - assert event["_meta"]["request"]["data"]["foo"] == { - "": { - "len": DEFAULT_MAX_VALUE_LENGTH + 10, - "rem": [ - ["!limit", "x", DEFAULT_MAX_VALUE_LENGTH - 3, DEFAULT_MAX_VALUE_LENGTH] - ], + if max_value_length: + assert event["_meta"]["request"]["data"]["foo"] == { + "": { + "len": 1034, + "rem": [["!limit", "x", 1021, 1024]], + } } - } - assert len(event["request"]["data"]["foo"]) == DEFAULT_MAX_VALUE_LENGTH + assert len(event["request"]["data"]["foo"]) == 1024 + else: + assert len(event["request"]["data"]["foo"]) == 1034 assert event["_meta"]["request"]["data"]["file"] == {"": {"rem": [["!raw", "x"]]}} assert not event["request"]["data"]["file"] diff --git a/tests/integrations/sqlalchemy/test_sqlalchemy.py b/tests/integrations/sqlalchemy/test_sqlalchemy.py index d2a31a55d5..44d1b82624 100644 --- a/tests/integrations/sqlalchemy/test_sqlalchemy.py +++ b/tests/integrations/sqlalchemy/test_sqlalchemy.py @@ -11,7 +11,7 @@ import sentry_sdk from sentry_sdk import capture_message, start_transaction -from sentry_sdk.consts import DEFAULT_MAX_VALUE_LENGTH, SPANDATA +from sentry_sdk.consts import SPANDATA from sentry_sdk.integrations.sqlalchemy import SqlalchemyIntegration from sentry_sdk.serializer import MAX_EVENT_BYTES from sentry_sdk.tracing_utils import record_sql_queries @@ -226,14 +226,16 @@ def test_long_sql_query_preserved(sentry_init, capture_events): assert description.endswith("SELECT 98 UNION SELECT 99") -def test_large_event_not_truncated(sentry_init, capture_events): +@pytest.mark.parametrize("max_value_length", [1024, None]) +def test_large_event_not_truncated(sentry_init, capture_events, max_value_length): sentry_init( traces_sample_rate=1, integrations=[SqlalchemyIntegration()], + max_value_length=max_value_length, ) events = capture_events() - long_str = "x" * (DEFAULT_MAX_VALUE_LENGTH + 10) + long_str = "x" * (1034) scope = sentry_sdk.get_isolation_scope() @@ -270,18 +272,19 @@ def processor(event, hint): assert description.startswith("SELECT 0") assert description.endswith("SELECT 98 UNION SELECT 99") - # Smoke check that truncation of other fields has not changed. - assert len(event["message"]) == DEFAULT_MAX_VALUE_LENGTH + if max_value_length: + # Smoke check that truncation of other fields has not changed. + assert len(event["message"]) == 1024 - # The _meta for other truncated fields should be there as well. - assert event["_meta"]["message"] == { - "": { - "len": DEFAULT_MAX_VALUE_LENGTH + 10, - "rem": [ - ["!limit", "x", DEFAULT_MAX_VALUE_LENGTH - 3, DEFAULT_MAX_VALUE_LENGTH] - ], + # The _meta for other truncated fields should be there as well. + assert event["_meta"]["message"] == { + "": { + "len": 1034, + "rem": [["!limit", "x", 1021, 1024]], + } } - } + else: + assert len(event["message"]) == 1034 def test_engine_name_not_string(sentry_init): diff --git a/tests/test_client.py b/tests/test_client.py index a5b0b44931..66789c5c7c 100644 --- a/tests/test_client.py +++ b/tests/test_client.py @@ -28,7 +28,7 @@ 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 sentry_sdk.consts import DEFAULT_MAX_BREADCRUMBS from typing import TYPE_CHECKING @@ -791,19 +791,19 @@ def test_databag_depth_stripping(sentry_init, capture_events): def test_databag_string_stripping(sentry_init, capture_events): - sentry_init() + sentry_init(max_value_length=1024) events = capture_events() del events[:] try: - a = "A" * DEFAULT_MAX_VALUE_LENGTH * 10 # noqa + a = "A" * 10240 # noqa 1 / 0 except Exception: capture_exception() (event,) = events - assert len(json.dumps(event)) < DEFAULT_MAX_VALUE_LENGTH * 10 + assert len(json.dumps(event)) < 10240 def test_databag_breadth_stripping(sentry_init, capture_events): @@ -1090,25 +1090,13 @@ def test_multiple_positional_args(sentry_init): assert "Only single positional argument is expected" in str(exinfo.value) -@pytest.mark.parametrize( - "sdk_options, expected_data_length", - [ - ({}, DEFAULT_MAX_VALUE_LENGTH), - ( - {"max_value_length": DEFAULT_MAX_VALUE_LENGTH + 1000}, - DEFAULT_MAX_VALUE_LENGTH + 1000, - ), - ], -) -def test_max_value_length_option( - sentry_init, capture_events, sdk_options, expected_data_length -): - sentry_init(sdk_options) +def test_max_value_length_option(sentry_init, capture_events): + sentry_init(max_value_length=2024) events = capture_events() - capture_message("a" * (DEFAULT_MAX_VALUE_LENGTH + 2000)) + capture_message("a" * (3024)) - assert len(events[0]["message"]) == expected_data_length + assert len(events[0]["message"]) == 2024 @pytest.mark.parametrize( diff --git a/tests/test_serializer.py b/tests/test_serializer.py index 2f44ba8a08..7a496d6d8a 100644 --- a/tests/test_serializer.py +++ b/tests/test_serializer.py @@ -2,7 +2,6 @@ import pytest -from sentry_sdk.consts import DEFAULT_MAX_VALUE_LENGTH from sentry_sdk.serializer import MAX_DATABAG_BREADTH, MAX_DATABAG_DEPTH, serialize try: @@ -166,12 +165,12 @@ def test_no_trimming_if_max_request_body_size_is_always(body_normalizer): assert result == data -def test_max_value_length_default(body_normalizer): - data = {"key": "a" * (DEFAULT_MAX_VALUE_LENGTH * 10)} +def test_no_value_truncation_by_default(body_normalizer): + data = {"key": "a" * (10240)} result = body_normalizer(data) - assert len(result["key"]) == DEFAULT_MAX_VALUE_LENGTH # fallback max length + assert len(result["key"]) == 10240 # fallback max length def test_max_value_length(body_normalizer):