chore: Drop tags auto-set by the SDK

MIGRATION_GUIDE.md

@@ -82,6 +82,7 @@ Looking to upgrade from Sentry SDK 2.x to 3.x? Here's a comprehensive list of wh
 - The deprecated `propagate_traces` option has been removed. Use `trace_propagation_targets` instead, which gives you more power over trace propagation. Note that only the top-level `init` option was removed; the `propagate_traces` option of the Celery integration remains available.
 - Removed Spotlight integration for Django. See [Spotlight 2.0](https://github.com/getsentry/spotlight/issues/891) for more context.
 - The deprecated parameter `propagate_hub` in `ThreadingIntegration()` was removed.
+- The SDK won't set any tags on its own anymore.
 - The `update_current_span` API was removed.
 
 ## Deprecated

sentry_sdk/integrations/asgi.py

@@ -299,9 +299,6 @@ async def _run_app(
                                 origin=self.span_origin,
                             )
 
-                        if transaction:
-                            transaction.set_tag("asgi.type", ty)
-
                         span_ctx = (
                             sentry_sdk.start_transaction(
                                 transaction,

sentry_sdk/integrations/aws_lambda.py

@@ -121,10 +121,6 @@ def sentry_handler(
                         request_data, aws_context, configured_time
                     )
                 )
-                scope.set_tag("aws_region", aws_region)
-                if batch_size > 1:
-                    scope.set_tag("batch_request", True)
-                    scope.set_tag("batch_size", batch_size)
 
                 # Starting the Timeout thread only if the configured time is greater than Timeout warning
                 # buffer and timeout_warning parameter is set True.

sentry_sdk/integrations/boto3.py

@@ -125,8 +125,6 @@ def _sentry_request_created(
                 }
             )
 
-        span.set_tag("aws.service_id", service_id.hyphenize())
-        span.set_tag("aws.operation_name", operation_name)
         if request.method is not None:
             span.set_data(SPANDATA.HTTP_METHOD, request.method)
             breadcrumb[SPANDATA.HTTP_METHOD] = request.method

sentry_sdk/integrations/django/middleware.py

@@ -13,7 +13,6 @@
 from sentry_sdk.tracing_utils import has_span_streaming_enabled
 from sentry_sdk.utils import (
     capture_internal_exceptions,
-    transaction_from_function,
 )
 
 if TYPE_CHECKING:
@@ -74,8 +73,6 @@ def _check_middleware_span(
         if integration is None or not integration.middleware_spans:
             return None
 
-        function_name = transaction_from_function(old_method)
-
         description = middleware_name
         function_basename = getattr(old_method, "__name__", None)
         if function_basename:
@@ -100,8 +97,6 @@ def _check_middleware_span(
                 name=description,
                 origin=DjangoIntegration.origin,
             )
-            middleware_span.set_tag("django.function_name", function_name)
-            middleware_span.set_tag("django.middleware_name", middleware_name)
 
         return middleware_span
 

sentry_sdk/integrations/gcp.py

@@ -68,7 +68,6 @@ def sentry_func(
                         gcp_event, configured_time, initial_time
                     )
                 )
-                scope.set_tag("gcp_region", environ.get("FUNCTION_REGION"))
                 timeout_thread = None
                 if (
                     integration.timeout_warning

sentry_sdk/integrations/litestar.py

@@ -230,8 +230,6 @@ async def _sentry_send(message: "Message") -> None:
                 name=middleware_name,
                 origin=LitestarIntegration.origin,
             ) as middleware_span:
-                middleware_span.set_tag("litestar.middleware_name", middleware_name)
-
                 # Creating spans for the "receive" callback
                 async def _sentry_receive(
                     *args: "Any", **kwargs: "Any"
@@ -242,8 +240,7 @@ async def _sentry_receive(
                         op=OP.MIDDLEWARE_LITESTAR_RECEIVE,
                         name=getattr(receive, "__qualname__", str(receive)),
                         origin=LitestarIntegration.origin,
-                    ) as span:
-                        span.set_tag("litestar.middleware_name", middleware_name)
+                    ):
                         return await receive(*args, **kwargs)
 
                 receive_name = getattr(receive, "__name__", str(receive))
@@ -258,8 +255,7 @@ async def _sentry_send(message: "Message") -> None:
                         op=OP.MIDDLEWARE_LITESTAR_SEND,
                         name=getattr(send, "__qualname__", str(send)),
                         origin=LitestarIntegration.origin,
-                    ) as span:
-                        span.set_tag("litestar.middleware_name", middleware_name)
+                    ):
                         return await send(message)
 
                 send_name = getattr(send, "__name__", str(send))

sentry_sdk/integrations/pymongo.py

@@ -221,9 +221,6 @@ def started(self, event: "CommandStartedEvent") -> None:
                 )
 
                 for tag, value in tags.items():
-                    # set the tag for backwards-compatibility.
-                    # TODO: remove the set_tag call in the next major release!
-                    span.set_tag(tag, value)
                     span.set_data(tag, value)
 
                 for key, value in data.items():

sentry_sdk/integrations/redis/utils.py

@@ -121,9 +121,6 @@ def _set_pipeline_data(
     if isinstance(span, StreamedSpan):
         return
 
-    span.set_tag("redis.is_cluster", is_cluster)
-    span.set_tag("redis.transaction", is_transaction)
-
     commands = []
     for i, arg in enumerate(commands_seq):
         if i >= _MAX_NUM_COMMANDS:
@@ -147,18 +144,11 @@ def _set_client_data(
     if isinstance(span, StreamedSpan):
         if name:
             span.set_attribute(SPANDATA.DB_OPERATION_NAME, name)
-    else:
-        span.set_tag("redis.is_cluster", is_cluster)
-        if name:
-            span.set_tag("redis.command", name)
-            span.set_tag(SPANDATA.DB_OPERATION, name)
 
     key = _extract_key(name, args)
     if key is not None:
         if isinstance(span, StreamedSpan):
             span.set_attribute("db.redis.key", key)
-        else:
-            span.set_tag("redis.key", key)
 
 
 def _extract_key(name: str, args: "Any") -> "Optional[str]":

sentry_sdk/integrations/starlette.py

@@ -190,20 +190,13 @@ def _start_middleware_span(op: str, name: str) -> "Any":
                 origin=StarletteIntegration.origin,
             )
 
-        with _start_middleware_span(
-            op=OP.MIDDLEWARE_STARLETTE, name=middleware_name
-        ) as middleware_span:
-            if not is_span_streaming_enabled:
-                middleware_span.set_tag("starlette.middleware_name", middleware_name)
-
+        with _start_middleware_span(op=OP.MIDDLEWARE_STARLETTE, name=middleware_name):
             # Creating spans for the "receive" callback
             async def _sentry_receive(*args: "Any", **kwargs: "Any") -> "Any":
                 with _start_middleware_span(
                     op=OP.MIDDLEWARE_STARLETTE_RECEIVE,
                     name=getattr(receive, "__qualname__", str(receive)),
-                ) as span:
-                    if not is_span_streaming_enabled:
-                        span.set_tag("starlette.middleware_name", middleware_name)
+                ):
                     return await receive(*args, **kwargs)
 
             receive_name = getattr(receive, "__name__", str(receive))
@@ -215,9 +208,7 @@ async def _sentry_send(*args: "Any", **kwargs: "Any") -> "Any":
                 with _start_middleware_span(
                     op=OP.MIDDLEWARE_STARLETTE_SEND,
                     name=getattr(send, "__qualname__", str(send)),
-                ) as span:
-                    if not is_span_streaming_enabled:
-                        span.set_tag("starlette.middleware_name", middleware_name)
+                ):
                     return await send(*args, **kwargs)
 
             send_name = getattr(send, "__name__", str(send))

sentry_sdk/integrations/starlite.py

@@ -173,12 +173,7 @@ def _start_middleware_span(op: str, name: str) -> "Any":
                 origin=StarliteIntegration.origin,
             )
 
-        with _start_middleware_span(
-            op=OP.MIDDLEWARE_STARLITE, name=middleware_name
-        ) as middleware_span:
-            if not is_span_streaming_enabled:
-                middleware_span.set_tag("starlite.middleware_name", middleware_name)
-
+        with _start_middleware_span(op=OP.MIDDLEWARE_STARLITE, name=middleware_name):
             # Creating spans for the "receive" callback
             async def _sentry_receive(
                 *args: "Any", **kwargs: "Any"
@@ -188,9 +183,7 @@ async def _sentry_receive(
                 with _start_middleware_span(
                     op=OP.MIDDLEWARE_STARLITE_RECEIVE,
                     name=getattr(receive, "__qualname__", str(receive)),
-                ) as span:
-                    if not is_span_streaming_enabled:
-                        span.set_tag("starlite.middleware_name", middleware_name)
+                ):
                     return await receive(*args, **kwargs)
 
             receive_name = getattr(receive, "__name__", str(receive))
@@ -204,9 +197,7 @@ async def _sentry_send(message: "Message") -> None:
                 with _start_middleware_span(
                     op=OP.MIDDLEWARE_STARLITE_SEND,
                     name=getattr(send, "__qualname__", str(send)),
-                ) as span:
-                    if not is_span_streaming_enabled:
-                        span.set_tag("starlite.middleware_name", middleware_name)
+                ):
                     return await send(message)
 
             send_name = getattr(send, "__name__", str(send))

tests/integrations/aws_lambda/test_aws_lambda.py

@@ -119,7 +119,6 @@ def test_basic_no_exception(lambda_client, test_environment):
     assert transaction_event["type"] == "transaction"
     assert transaction_event["transaction"] == "BasicOk"
     assert transaction_event["sdk"]["name"] == "sentry.python.aws_lambda"
-    assert transaction_event["tags"] == {"aws_region": "us-east-1"}
 
     assert transaction_event["extra"]["cloudwatch logs"] == {
         "log_group": mock.ANY,
@@ -161,7 +160,6 @@ def test_basic_exception(lambda_client, test_environment):
     assert error_event["exception"]["values"][0]["value"] == "Oh!"
     assert error_event["sdk"]["name"] == "sentry.python.aws_lambda"
 
-    assert error_event["tags"] == {"aws_region": "us-east-1"}
     assert error_event["extra"]["cloudwatch logs"] == {
         "log_group": mock.ANY,
         "log_stream": mock.ANY,
@@ -325,12 +323,6 @@ def test_non_dict_event(
     assert error_event["request"] == request_data
     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
-
 
 def test_request_data_with_send_default_pii_false(lambda_client, test_environment):
     payload = b"""

tests/integrations/litestar/test_litestar.py

@@ -270,7 +270,6 @@ def test_middleware_spans(
             assert span["description"] in expected
             assert span["description"] not in found
             found.add(span["description"])
-            assert span["description"] == span["tags"]["litestar.middleware_name"]
 
 
 @pytest.mark.parametrize("span_streaming", [True, False])
@@ -359,25 +358,21 @@ def is_matching_span(expected_span, actual_span):
             {
                 "op": "middleware.litestar",
                 "description": "SampleMiddleware",
-                "tags": {"litestar.middleware_name": "SampleMiddleware"},
             },
             {
                 "op": "middleware.litestar.send",
                 "description": "SentryAsgiMiddleware._run_app.<locals>._sentry_wrapped_send",
-                "tags": {"litestar.middleware_name": "SampleMiddleware"},
             },
             {
                 "op": "middleware.litestar.send",
                 "description": "SentryAsgiMiddleware._run_app.<locals>._sentry_wrapped_send",
-                "tags": {"litestar.middleware_name": "SampleMiddleware"},
             },
         ]
 
         def is_matching_span(expected_span, actual_span):
             return (
                 expected_span["op"] == actual_span["op"]
                 and expected_span["description"] == actual_span["description"]
-                and expected_span["tags"] == actual_span["tags"]
             )
 
         actual_litestar_spans = list(
@@ -518,32 +513,21 @@ def is_matching_span(expected_span, actual_span):
             {
                 "op": "middleware.litestar",
                 "description": "SamplePartialReceiveSendMiddleware",
-                "tags": {
-                    "litestar.middleware_name": "SamplePartialReceiveSendMiddleware"
-                },
             },
             {
                 "op": "middleware.litestar.receive",
                 "description": "TestClientTransport.create_receive.<locals>.receive",
-                "tags": {
-                    "litestar.middleware_name": "SamplePartialReceiveSendMiddleware"
-                },
             },
             {
                 "op": "middleware.litestar.send",
                 "description": "SentryAsgiMiddleware._run_app.<locals>._sentry_wrapped_send",
-                "tags": {
-                    "litestar.middleware_name": "SamplePartialReceiveSendMiddleware"
-                },
             },
         ]
 
         def is_matching_span(expected_span, actual_span):
-            return (
-                expected_span["op"] == actual_span["op"]
-                and actual_span["description"].startswith(expected_span["description"])
-                and expected_span["tags"] == actual_span["tags"]
-            )
+            return expected_span["op"] == actual_span["op"] and actual_span[
+                "description"
+            ].startswith(expected_span["description"])
 
         actual_litestar_spans = list(
             span

tests/integrations/pymongo/test_pymongo.py

@@ -64,30 +64,23 @@ def test_transactions(sentry_init, capture_events, mongo_server, with_pii):
         assert span["data"][SPANDATA.SERVER_ADDRESS] == "localhost"
         assert span["data"][SPANDATA.SERVER_PORT] == mongo_server.port
         for field, value in common_tags.items():
-            assert span["tags"][field] == value
             assert span["data"][field] == value
 
     assert find["op"] == "db"
     assert insert_success["op"] == "db"
     assert insert_fail["op"] == "db"
 
     assert find["data"]["db.operation"] == "find"
-    assert find["tags"]["db.operation"] == "find"
     assert insert_success["data"]["db.operation"] == "insert"
-    assert insert_success["tags"]["db.operation"] == "insert"
     assert insert_fail["data"]["db.operation"] == "insert"
-    assert insert_fail["tags"]["db.operation"] == "insert"
 
     assert find["description"].startswith('{"find')
     assert insert_success["description"].startswith('{"insert')
     assert insert_fail["description"].startswith('{"insert')
 
     assert find["data"][SPANDATA.DB_MONGODB_COLLECTION] == "test_collection"
-    assert find["tags"][SPANDATA.DB_MONGODB_COLLECTION] == "test_collection"
     assert insert_success["data"][SPANDATA.DB_MONGODB_COLLECTION] == "test_collection"
-    assert insert_success["tags"][SPANDATA.DB_MONGODB_COLLECTION] == "test_collection"
     assert insert_fail["data"][SPANDATA.DB_MONGODB_COLLECTION] == "erroneous"
-    assert insert_fail["tags"][SPANDATA.DB_MONGODB_COLLECTION] == "erroneous"
     if with_pii:
         assert "1" in find["description"]
         assert "2" in insert_success["description"]
@@ -103,11 +96,8 @@ def test_transactions(sentry_init, capture_events, mongo_server, with_pii):
         )
 
     assert find["status"] == "ok"
-    assert find["tags"]["status"] == "ok"
     assert insert_success["status"] == "ok"
-    assert insert_success["tags"]["status"] == "ok"
     assert insert_fail["status"] == "internal_error"
-    assert insert_fail["tags"]["status"] == "internal_error"
 
 
 DATA_COLLECTION_DATABASE_QUERY_DATA_USE_CASES = [

tests/integrations/redis/asyncio/test_redis_asyncio.py

@@ -113,10 +113,6 @@ async def test_async_redis_pipeline(
                 SPANDATA.SERVER_PORT: 6379,
             }
         )
-        assert span["tags"] == {
-            "redis.transaction": is_transaction,
-            "redis.is_cluster": False,
-        }
 
 
 @pytest.mark.parametrize("span_streaming", [True, False])

tests/integrations/redis/cluster/test_redis_cluster.py

@@ -132,12 +132,6 @@ def test_rediscluster_basic(
                 SPANDATA.SERVER_PORT: 6379,
             }
         )
-        assert span["tags"] == {
-            "db.operation": "SET",
-            "redis.command": "SET",
-            "redis.is_cluster": True,
-            "redis.key": "bar",
-        }
 
 
 @pytest.mark.parametrize("span_streaming", [True, False])
@@ -217,10 +211,6 @@ def test_rediscluster_pipeline(
                 SPANDATA.SERVER_PORT: 6379,
             }
         )
-        assert span["tags"] == {
-            "redis.transaction": False,  # For Cluster, this is always False
-            "redis.is_cluster": True,
-        }
 
 
 @pytest.mark.parametrize("span_streaming", [True, False])