Convert tag values to strings in Sentry SDK

Ensure tag values are always converted to strings using safe_str

clean up Cursor's solution

Convert tag values from int to str in scope and compatibility tests

Checkpoint before follow-up message

Fix request_data tag assertions in integration tests

Convert boolean tags to strings in Redis and AWS Lambda integrations

tests: Regenerate tox (#4457)

(Yeah I'll automate this at some point)

reformat tests

fix `test_memory_usage`

fix apidocs

Only convert to string when serializing

fix tests

Author: cursoragent

sentry_sdk/opentelemetry/span_processor.py

@@ -37,6 +37,7 @@
     try_profile_lifecycle_trace_start,
 )
 from sentry_sdk.profiler.transaction_profiler import Profile
+from sentry_sdk.utils import safe_str
 from sentry_sdk._types import TYPE_CHECKING
 
 if TYPE_CHECKING:
@@ -311,7 +312,9 @@ def _common_span_transaction_attributes_as_json(self, span):
 
         tags = extract_span_attributes(span, SentrySpanAttribute.TAG)
         if tags:
-            common_json["tags"] = tags
+            common_json["tags"] = {
+                tag: safe_str(tag_value) for tag, tag_value in tags.items()
+            }
 
         return common_json
 

sentry_sdk/scope.py

@@ -38,6 +38,7 @@
     event_from_exception,
     exc_info_from_error,
     logger,
+    safe_str,
 )
 
 from typing import TYPE_CHECKING
@@ -1164,7 +1165,9 @@ def _apply_extra_to_event(self, event, hint, options):
     def _apply_tags_to_event(self, event, hint, options):
         # type: (Event, Hint, Optional[Dict[str, Any]]) -> None
         if self._tags:
-            event.setdefault("tags", {}).update(self._tags)
+            event.setdefault("tags", {}).update(
+                {k: safe_str(v) for k, v in self._tags.items()}
+            )
 
     def _apply_contexts_to_event(self, event, hint, options):
         # type: (Event, Hint, Optional[Dict[str, Any]]) -> None

tests/integrations/aws_lambda/test_aws_lambda.py

@@ -322,10 +322,10 @@ def test_non_dict_event(
     assert transaction_event["request"] == request_data
 
     if batch_size > 1:
-        assert error_event["tags"]["batch_size"] == batch_size
-        assert error_event["tags"]["batch_request"] is True
-        assert transaction_event["tags"]["batch_size"] == batch_size
-        assert transaction_event["tags"]["batch_request"] is True
+        assert error_event["tags"]["batch_size"] == str(batch_size)
+        assert error_event["tags"]["batch_request"] == "True"
+        assert transaction_event["tags"]["batch_size"] == str(batch_size)
+        assert transaction_event["tags"]["batch_request"] == "True"
 
 
 def test_request_data(lambda_client, test_environment):

tests/integrations/redis/asyncio/test_redis_asyncio.py

@@ -78,8 +78,8 @@ async def test_async_redis_pipeline(
         }
     )
     assert span["tags"] == {
-        "redis.transaction": is_transaction,
-        "redis.is_cluster": False,
+        "redis.transaction": str(is_transaction),
+        "redis.is_cluster": "False",
     }
 
 

tests/integrations/redis/cluster/test_redis_cluster.py

@@ -94,7 +94,7 @@ def test_rediscluster_basic(sentry_init, capture_events, send_default_pii, descr
     assert span["tags"] == {
         "db.operation": "SET",
         "redis.command": "SET",
-        "redis.is_cluster": True,
+        "redis.is_cluster": "True",
         "redis.key": "bar",
     }
 
@@ -139,8 +139,8 @@ def test_rediscluster_pipeline(
         }
     )
     assert span["tags"] == {
-        "redis.transaction": False,  # For Cluster, this is always False
-        "redis.is_cluster": True,
+        "redis.transaction": "False",  # For Cluster, this is always False
+        "redis.is_cluster": "True",
     }
 
 

tests/integrations/redis/cluster_asyncio/test_redis_cluster_asyncio.py

@@ -94,7 +94,7 @@ async def test_async_basic(sentry_init, capture_events, send_default_pii, descri
         }
     )
     assert span["tags"] == {
-        "redis.is_cluster": True,
+        "redis.is_cluster": "True",
         "db.operation": "SET",
         "redis.command": "SET",
         "redis.key": "bar",
@@ -142,8 +142,8 @@ async def test_async_redis_pipeline(
         }
     )
     assert span["tags"] == {
-        "redis.transaction": False,
-        "redis.is_cluster": True,
+        "redis.transaction": "False",
+        "redis.is_cluster": "True",
     }
 
 

tests/integrations/redis/test_redis.py

@@ -75,8 +75,8 @@ def test_redis_pipeline(
     assert span["data"]["redis.commands.count"] == 3
     assert span["data"]["redis.commands.first_ten"] == expected_first_ten
     assert span["tags"] == {
-        "redis.transaction": is_transaction,
-        "redis.is_cluster": False,
+        "redis.transaction": str(is_transaction),
+        "redis.is_cluster": "False",
     }
 
 

tests/integrations/redis_py_cluster_legacy/test_redis_py_cluster_legacy.py

@@ -106,8 +106,8 @@ def test_rediscluster_pipeline(
         }
     )
     assert span["tags"] == {
-        "redis.transaction": False,  # For Cluster, this is always False
-        "redis.is_cluster": True,
+        "redis.transaction": "False",  # For Cluster, this is always False
+        "redis.is_cluster": "True",
     }
 
 

tests/test_api.py

@@ -14,6 +14,7 @@
     set_tags,
     get_global_scope,
     get_isolation_scope,
+    set_tag,
 )
 
 from sentry_sdk.client import Client, NonRecordingClient
@@ -158,3 +159,82 @@ def test_set_tags(sentry_init, capture_events):
         "tag2": "updated",
         "tag3": "new",
     }, "Updating tags with empty dict changed tags"
+
+
+@pytest.mark.parametrize(
+    ("key", "value", "expected"),
+    [
+        ("int", 123, "123"),
+        ("float", 123.456, "123.456"),
+        ("bool", True, "True"),
+        ("none", None, "None"),
+        ("list", [1, 2, 3], "[1, 2, 3]"),
+    ],
+)
+def test_set_tag_converts_to_string(sentry_init, capture_events, key, value, expected):
+    """Test that the api.set_tag function converts values to strings."""
+    sentry_init()
+    events = capture_events()
+
+    set_tag(key, value)
+    raise_and_capture()
+
+    (event,) = events
+    tags = event.get("tags", {})
+
+    assert tags[key] == expected
+
+
+def test_set_tags_converts_to_string(sentry_init, capture_events):
+    """Test that the api.set_tags function converts values to strings."""
+    sentry_init()
+    events = capture_events()
+
+    set_tags(
+        {
+            "int": 456,
+            "float": 789.012,
+            "bool": False,
+            "tuple": (1, 2, 3),
+            "string": "already_string",
+        }
+    )
+
+    raise_and_capture()
+
+    (*_, event) = events
+    tags = event.get("tags", {})
+
+    assert tags["int"] == "456"
+    assert tags["float"] == "789.012"
+    assert tags["bool"] == "False"
+    assert tags["tuple"] == "(1, 2, 3)"
+    assert tags["string"] == "already_string"
+
+
+def test_configure_scope_deprecation():
+    with pytest.warns(DeprecationWarning):
+        with configure_scope():
+            ...
+
+
+def test_push_scope_deprecation():
+    with pytest.warns(DeprecationWarning):
+        with push_scope():
+            ...
+
+
+def test_init_context_manager_deprecation():
+    with pytest.warns(DeprecationWarning):
+        with sentry_sdk.init():
+            ...
+
+
+def test_init_enter_deprecation():
+    with pytest.warns(DeprecationWarning):
+        sentry_sdk.init().__enter__()
+
+
+def test_init_exit_deprecation():
+    with pytest.warns(DeprecationWarning):
+        sentry_sdk.init().__exit__(None, None, None)

tests/test_scope.py

@@ -823,9 +823,13 @@ def test_nested_scopes_with_tags(sentry_init, capture_envelopes):
     (envelope,) = envelopes
     transaction = envelope.items[0].get_transaction_event()
 
-    assert transaction["tags"] == {"isolation_scope1": 1, "current_scope2": 1, "trx": 1}
-    assert transaction["spans"][0]["tags"] == ApproxDict({"a": 1})
-    assert transaction["spans"][1]["tags"] == ApproxDict({"b": 1})
+    assert transaction["tags"] == {
+        "isolation_scope1": "1",
+        "current_scope2": "1",
+        "trx": "1",
+    }
+    assert transaction["spans"][0]["tags"] == ApproxDict({"a": "1"})
+    assert transaction["spans"][1]["tags"] == ApproxDict({"b": "1"})
 
 
 def test_should_send_default_pii_true(sentry_init):
@@ -931,3 +935,107 @@ def test_root_span(sentry_init):
                 assert sentry_sdk.get_current_scope().root_span == root_span
 
     assert sentry_sdk.get_current_scope().root_span is None
+
+
+@pytest.mark.parametrize(
+    ("key", "value", "expected"),
+    [
+        ("int", 123, "123"),
+        ("float", 123.456, "123.456"),
+        ("bool_true", True, "True"),
+        ("bool_false", False, "False"),
+        ("none", None, "None"),
+        ("list", [1, 2, 3], "[1, 2, 3]"),
+        ("dict", {"key": "value"}, "{'key': 'value'}"),
+        ("already_string", "test", "test"),
+    ],
+)
+def test_set_tag_converts_to_string(key, value, expected):
+    """Test that set_tag converts various types to strings."""
+    scope = Scope()
+    scope.set_tag(key, value)
+
+    event = scope.apply_to_event({}, {})
+    tags = event.get("tags", {})
+
+    assert tags[key] == expected, f"Tag {key} was not converted properly"
+
+
+def test_set_tags_converts_to_string():
+    """Test that set_tags converts all values to strings."""
+    scope = Scope()
+
+    scope.set_tags(
+        {
+            "int": 123,
+            "float": 123.456,
+            "bool": True,
+            "none": None,
+            "list": [1, 2, 3],
+            "string": "test",
+        }
+    )
+
+    event = scope.apply_to_event({}, {})
+    tags = event.get("tags", {})
+
+    assert tags["int"] == "123"
+    assert tags["float"] == "123.456"
+    assert tags["bool"] == "True"
+    assert tags["none"] == "None"
+    assert tags["list"] == "[1, 2, 3]"
+    assert tags["string"] == "test"
+
+
+def test_set_tag_handles_conversion_failure():
+    """Test that set_tag handles objects that fail to convert to string."""
+    scope = Scope()
+
+    # Create an object that raises an exception when str() is called
+    class BadObject:
+        def __str__(self):
+            raise Exception("Cannot convert to string")
+
+        def __repr__(self):
+            return "BadObject()"
+
+    bad_obj = BadObject()
+
+    # This should not raise an exception
+    scope.set_tag("bad_object", bad_obj)
+
+    # The tag should be set with the repr value
+    event = scope.apply_to_event({}, {})
+    tags = event.get("tags", {})
+
+    assert tags["bad_object"] == "BadObject()", "Tag should be set with repr value"
+
+
+def test_set_tags_handles_conversion_failure():
+    """Test that set_tags handles objects that fail to convert to string."""
+    scope = Scope()
+
+    # Create an object that raises an exception when str() is called
+    class BadObject:
+        def __str__(self):
+            raise Exception("Cannot convert to string")
+
+        def __repr__(self):
+            return "BadObject()"
+
+    bad_obj = BadObject()
+
+    scope.set_tags(
+        {
+            "good_tag1": "value1",
+            "bad_tag": bad_obj,
+            "good_tag2": 123,
+        }
+    )
+
+    event = scope.apply_to_event({}, {})
+    tags = event.get("tags", {})
+
+    assert tags["good_tag1"] == "value1"
+    assert tags["bad_tag"] == "BadObject()", "Tag should be set with repr value"
+    assert tags["good_tag2"] == "123"