remove op, origin, source setters

sentrivana · sentrivana · commit 88cfd8b84429 · 2026-02-26T15:23:29.000+01:00
diff --git a/sentry_sdk/integrations/asgi.py b/sentry_sdk/integrations/asgi.py
@@ -227,17 +227,22 @@ async def _run_app(
                                 segment = sentry_sdk.traces.start_span(
                                     name=transaction_name
                                 )
-                                segment.set_op(f"{ty}.server")
+                                segment.set_attribute("sentry.op", f"{ty}.server")
                         else:
                             sentry_sdk.traces.new_trace()
                             segment = sentry_sdk.traces.start_span(
                                 name=transaction_name,
                             )
-                            segment.set_op(OP.HTTP_SERVER)
+                            segment.set_attribute("sentry.op", OP.HTTP_SERVER)
 
                         if segment is not None:
-                            segment.set_source(transaction_source)
-                            segment.set_origin(self.span_origin)
+                            segment.set_attribute(
+                                "sentry.span.source",
+                                getattr(
+                                    transaction_source, "value", transaction_source
+                                ),
+                            )
+                            segment.set_attribute("sentry.origin", self.span_origin)
                             segment.set_attribute("asgi.type", ty)
 
                         span_ctx = segment or nullcontext()
diff --git a/sentry_sdk/integrations/celery/__init__.py b/sentry_sdk/integrations/celery/__init__.py
@@ -281,8 +281,8 @@ def apply_async(*args: "Any", **kwargs: "Any") -> "Any":
         if span_streaming:
             if not task_started_from_beat:
                 span_mgr = sentry_sdk.traces.start_span(name=task_name)
-                span_mgr.set_op(OP.QUEUE_SUBMIT_CELERY)
-                span_mgr.set_origin(CeleryIntegration.origin)
+                span_mgr.set_attribute("sentry.op", OP.QUEUE_SUBMIT_CELERY)
+                span_mgr.set_attribute("sentry.origin", CeleryIntegration.origin)
         else:
             if not task_started_from_beat:
                 span_mgr = sentry_sdk.start_span(
@@ -330,9 +330,11 @@ def _inner(*args: "Any", **kwargs: "Any") -> "Any":
                 if span_streaming:
                     sentry_sdk.traces.continue_trace(headers)
                     transaction = sentry_sdk.traces.start_span(name=task.name)
-                    transaction.set_origin(CeleryIntegration.origin)
-                    transaction.set_source(TransactionSource.TASK)
-                    transaction.set_op(OP.QUEUE_TASK_CELERY)
+                    transaction.set_attribute("sentry.origin", CeleryIntegration.origin)
+                    transaction.set_attribute(
+                        "sentry.span.source", TransactionSource.TASK.value
+                    )
+                    transaction.set_attribute("sentry.op", OP.QUEUE_TASK_CELERY)
 
                     span_ctx = transaction
 
@@ -401,8 +403,8 @@ def _inner(*args: "Any", **kwargs: "Any") -> "Any":
             span: "Union[Span, StreamedSpan]"
             if span_streaming:
                 span = sentry_sdk.traces.start_span(name=task.name)
-                span.set_op(OP.QUEUE_PROCESS)
-                span.set_origin(CeleryIntegration.origin)
+                span.set_attribute("sentry.op", OP.QUEUE_PROCESS)
+                span.set_attribute("sentry.origin", CeleryIntegration.origin)
             else:
                 span = sentry_sdk.start_span(
                     op=OP.QUEUE_PROCESS,
@@ -547,8 +549,8 @@ def sentry_publish(self: "Producer", *args: "Any", **kwargs: "Any") -> "Any":
         span: "Union[StreamedSpan, Span]"
         if span_streaming:
             span = sentry_sdk.traces.start_span(name=task_name)
-            span.set_op(OP.QUEUE_PUBLISH)
-            span.set_origin(CeleryIntegration.origin)
+            span.set_attribute("sentry.op", OP.QUEUE_PUBLISH)
+            span.set_attribute("sentry.origin", CeleryIntegration.origin)
         else:
             span = sentry_sdk.start_span(
                 op=OP.QUEUE_PUBLISH,
diff --git a/sentry_sdk/integrations/graphene.py b/sentry_sdk/integrations/graphene.py
@@ -150,7 +150,7 @@ def graphql_span(
     _graphql_span: "Union[Span, StreamedSpan]"
     if span_streaming:
         _graphql_span = sentry_sdk.traces.start_span(name=operation_name or "operation")
-        _graphql_span.set_op(op)
+        _graphql_span.set_attribute("sentry.op", op)
         _graphql_span.set_attribute("graphql.document", source)
         if operation_name:
             _graphql_span.set_attribute("graphql.operation.name", operation_name)
diff --git a/sentry_sdk/integrations/httpx.py b/sentry_sdk/integrations/httpx.py
@@ -78,8 +78,8 @@ def send(self: "Client", request: "Request", **kwargs: "Any") -> "Response":
 
         with span_ctx as span:
             if isinstance(span, StreamedSpan):
-                span.set_op(OP.HTTP_CLIENT)
-                span.set_origin(HttpxIntegration.origin)
+                span.set_attribute("sentry.op", OP.HTTP_CLIENT)
+                span.set_attribute("sentry.origin", HttpxIntegration.origin)
 
                 span.set_attribute(SPANDATA.HTTP_METHOD, request.method)
                 if parsed_url is not None:
@@ -159,8 +159,8 @@ async def send(
 
         with span_ctx as span:
             if isinstance(span, StreamedSpan):
-                span.set_op(OP.HTTP_CLIENT)
-                span.set_origin(HttpxIntegration.origin)
+                span.set_attribute("sentry.op", OP.HTTP_CLIENT)
+                span.set_attribute("sentry.origin", HttpxIntegration.origin)
                 span.set_attribute(SPANDATA.HTTP_METHOD, request.method)
                 if parsed_url is not None:
                     span.set_attribute("url", parsed_url.url)
diff --git a/sentry_sdk/integrations/huggingface_hub.py b/sentry_sdk/integrations/huggingface_hub.py
@@ -94,8 +94,8 @@ def new_huggingface_task(*args: "Any", **kwargs: "Any") -> "Any":
         span: "Union[StreamedSpan, Span]"
         if span_streaming:
             span = sentry_sdk.traces.start_span(name=f"{operation_name} {model}")
-            span.set_op(op)
-            span.set_origin(HuggingfaceHubIntegration.origin)
+            span.set_attribute("sentry.op", op)
+            span.set_attribute("sentry.origin", HuggingfaceHubIntegration.origin)
         else:
             span = sentry_sdk.start_span(
                 op=op,
diff --git a/sentry_sdk/integrations/redis/_async_common.py b/sentry_sdk/integrations/redis/_async_common.py
@@ -44,8 +44,8 @@ async def _sentry_execute(self: "Any", *args: "Any", **kwargs: "Any") -> "Any":
         span: "Union[Span, StreamedSpan]"
         if span_streaming:
             span = sentry_sdk.traces.start_span(name="redis.pipeline.execute")
-            span.set_origin(SPAN_ORIGIN)
-            span.set_op(OP.DB_REDIS)
+            span.set_attribute("sentry.origin", SPAN_ORIGIN)
+            span.set_attribute("sentry.op", OP.DB_REDIS)
         else:
             span = sentry_sdk.start_span(
                 op=OP.DB_REDIS,
@@ -109,8 +109,8 @@ async def _sentry_execute_command(
                 cache_span = sentry_sdk.traces.start_span(
                     name=cache_properties["description"]
                 )
-                cache_span.set_op(cache_properties["op"])
-                cache_span.set_origin(SPAN_ORIGIN)
+                cache_span.set_attribute("sentry.op", cache_properties["op"])
+                cache_span.set_attribute("sentry.origin", SPAN_ORIGIN)
             else:
                 cache_span = sentry_sdk.start_span(
                     op=cache_properties["op"],
@@ -124,8 +124,8 @@ async def _sentry_execute_command(
         db_span: "Union[Span, StreamedSpan]"
         if span_streaming:
             db_span = sentry_sdk.traces.start_span(name=db_properties["description"])
-            db_span.set_op(db_properties["op"])
-            db_span.set_origin(SPAN_ORIGIN)
+            db_span.set_attribute("sentry.op", db_properties["op"])
+            db_span.set_attribute("sentry.origin", SPAN_ORIGIN)
         else:
             db_span = sentry_sdk.start_span(
                 op=db_properties["op"],
diff --git a/sentry_sdk/integrations/redis/_sync_common.py b/sentry_sdk/integrations/redis/_sync_common.py
@@ -42,8 +42,8 @@ def sentry_patched_execute(self: "Any", *args: "Any", **kwargs: "Any") -> "Any":
         span: "Union[Span, StreamedSpan]"
         if span_streaming:
             span = sentry_sdk.traces.start_span(name="redis.pipeline.execute")
-            span.set_origin(SPAN_ORIGIN)
-            span.set_op(OP.DB_REDIS)
+            span.set_attribute("sentry.origin", SPAN_ORIGIN)
+            span.set_attribute("sentry.op", OP.DB_REDIS)
         else:
             span = sentry_sdk.start_span(
                 op=OP.DB_REDIS,
@@ -109,8 +109,8 @@ def sentry_patched_execute_command(
                 cache_span = sentry_sdk.traces.start_span(
                     name=cache_properties["description"]
                 )
-                cache_span.set_op(cache_properties["op"])
-                cache_span.set_origin(SPAN_ORIGIN)
+                cache_span.set_attribute("sentry.op", cache_properties["op"])
+                cache_span.set_attribute("sentry.origin", SPAN_ORIGIN)
             else:
                 cache_span = sentry_sdk.start_span(
                     op=cache_properties["op"],
@@ -124,8 +124,8 @@ def sentry_patched_execute_command(
         db_span: "Union[Span, StreamedSpan]"
         if span_streaming:
             db_span = sentry_sdk.traces.start_span(name=db_properties["description"])
-            db_span.set_op(db_properties["op"])
-            db_span.set_origin(SPAN_ORIGIN)
+            db_span.set_attribute("sentry.op", db_properties["op"])
+            db_span.set_attribute("sentry.origin", SPAN_ORIGIN)
         else:
             db_span = sentry_sdk.start_span(
                 op=db_properties["op"],
diff --git a/sentry_sdk/integrations/rust_tracing.py b/sentry_sdk/integrations/rust_tracing.py
@@ -216,8 +216,8 @@ def on_new_span(self, attrs: str, span_id: str) -> "TraceState":
                 sentry_span = sentry_sdk.traces.start_span(
                     name=sentry_span_name, parent_span=parent_sentry_span
                 )
-                sentry_span.set_op("function")
-                sentry_span.set_origin(self.origin)
+                sentry_span.set_attribute("sentry.op", "function")
+                sentry_span.set_attribute("sentry.origin", self.origin)
                 sentry_span.start()
             else:
                 sentry_span = parent_sentry_span.start_child(
@@ -232,8 +232,8 @@ def on_new_span(self, attrs: str, span_id: str) -> "TraceState":
                 sentry_span = sentry_sdk.traces.start_span(
                     name=sentry_span_name,
                 )
-                sentry_span.set_op("function")
-                sentry_span.set_origin(self.origin)
+                sentry_span.set_attribute("sentry.op", "function")
+                sentry_span.set_attribute("sentry.origin", self.origin)
                 sentry_span.start()
             else:
                 sentry_span = sentry_sdk.start_span(
diff --git a/sentry_sdk/integrations/starlette.py b/sentry_sdk/integrations/starlette.py
@@ -174,8 +174,8 @@ async def _create_span_call(
         middleware_span: "Optional[Union[Span, StreamedSpan]]" = None
         if span_streaming:
             middleware_span = sentry_sdk.traces.start_span(name=middleware_name)
-            middleware_span.set_op(OP.MIDDLEWARE_STARLETTE)
-            middleware_span.set_origin(StarletteIntegration.origin)
+            middleware_span.set_attribute("sentry.op", OP.MIDDLEWARE_STARLETTE)
+            middleware_span.set_attribute("sentry.origin", StarletteIntegration.origin)
             middleware_span.set_attribute("starlette.middleware_name", middleware_name)
         else:
             middleware_span = sentry_sdk.start_span(
@@ -193,8 +193,8 @@ async def _sentry_receive(*args: "Any", **kwargs: "Any") -> "Any":
                     span = sentry_sdk.traces.start_span(
                         name=getattr(receive, "__qualname__", str(receive)),
                     )
-                    span.set_origin(StarletteIntegration.origin)
-                    span.set_op(OP.MIDDLEWARE_STARLETTE_RECEIVE)
+                    span.set_attribute("sentry.origin", StarletteIntegration.origin)
+                    span.set_attribute("sentry.op", OP.MIDDLEWARE_STARLETTE_RECEIVE)
                     span.set_attribute("starlette.middleware_name", middleware_name)
                 else:
                     span = sentry_sdk.start_span(
@@ -218,8 +218,8 @@ async def _sentry_send(*args: "Any", **kwargs: "Any") -> "Any":
                     span = sentry_sdk.traces.start_span(
                         name=getattr(send, "__qualname__", str(send)),
                     )
-                    span.set_op(OP.MIDDLEWARE_STARLETTE_SEND)
-                    span.set_origin(StarletteIntegration.origin)
+                    span.set_attribute("sentry.op", OP.MIDDLEWARE_STARLETTE_SEND)
+                    span.set_attribute("sentry.origin", StarletteIntegration.origin)
                     span.set_attribute("starlette.middleware_name", middleware_name)
                 else:
                     span = sentry_sdk.start_span(
diff --git a/sentry_sdk/integrations/stdlib.py b/sentry_sdk/integrations/stdlib.py
@@ -110,8 +110,8 @@ def putrequest(
             span = sentry_sdk.traces.start_span(
                 name=f"{method} {parsed_url.url if parsed_url else SENSITIVE_DATA_SUBSTITUTE}"
             )
-            span.set_op(OP.HTTP_CLIENT)
-            span.set_origin("auto.http.stdlib.httplib")
+            span.set_attribute("sentry.op", OP.HTTP_CLIENT)
+            span.set_attribute("sentry.origin", "auto.http.stdlib.httplib")
 
             span.set_attribute(SPANDATA.HTTP_METHOD, method)
             if parsed_url is not None:
@@ -269,8 +269,8 @@ def sentry_patched_popen_init(
             span = sentry_sdk.traces.start_span(
                 name=description,
             )
-            span.set_op(OP.SUBPROCESS)
-            span.set_origin("auto.subprocess.stdlib.subprocess")
+            span.set_attribute("sentry.op", OP.SUBPROCESS)
+            span.set_attribute("sentry.origin", "auto.subprocess.stdlib.subprocess")
         else:
             span = sentry_sdk.start_span(
                 op=OP.SUBPROCESS,
@@ -321,8 +321,8 @@ def sentry_patched_popen_wait(
         span: "Optional[Union[Span, StreamedSpan]]" = None
         if span_streaming:
             span = sentry_sdk.traces.start_span(name="subprocess popen")
-            span.set_op(OP.SUBPROCESS_WAIT)
-            span.set_origin("auto.subprocess.stdlib.subprocess")
+            span.set_attribute("sentry.op", OP.SUBPROCESS_WAIT)
+            span.set_attribute("sentry.origin", "auto.subprocess.stdlib.subprocess")
             span.set_attribute("subprocess.pid", self.pid)
         else:
             span = sentry_sdk.start_span(
@@ -350,8 +350,8 @@ def sentry_patched_popen_communicate(
             span = sentry_sdk.traces.start_span(
                 name="subprocess communicate",
             )
-            span.set_op(OP.SUBPROCESS_COMMUNICATE)
-            span.set_origin("auto.subprocess.stdlib.subprocess")
+            span.set_attribute("sentry.op", OP.SUBPROCESS_COMMUNICATE)
+            span.set_attribute("sentry.origin", "auto.subprocess.stdlib.subprocess")
             span.set_attribute("subprocess.pid", self.pid)
         else:
             span = sentry_sdk.start_span(
diff --git a/sentry_sdk/integrations/strawberry.py b/sentry_sdk/integrations/strawberry.py
@@ -192,8 +192,10 @@ def on_operation(self) -> "Generator[None, None, None]":
             self.graphql_span = sentry_sdk.traces.start_span(
                 name=description,
             )
-            self.graphql_span.set_op(op)
-            self.graphql_span.set_origin(StrawberryIntegration.origin)
+            self.graphql_span.set_attribute("sentry.op", op)
+            self.graphql_span.set_attribute(
+                "sentry.origin", StrawberryIntegration.origin
+            )
 
             self.graphql_span.set_attribute("graphql.operation.type", operation_type)
             if self._operation_name:
@@ -226,7 +228,7 @@ def on_operation(self) -> "Generator[None, None, None]":
                 TransactionSource.COMPONENT,
             )
             if isinstance(self.graphql_span, StreamedSpan):
-                self.graphql_span.segment.set_op(op)
+                self.graphql_span.segment.set_attribute("sentry.op", op)
             else:
                 if self.graphql_span.containing_transaction:
                     self.graphql_span.containing_transaction.op = op
@@ -243,8 +245,9 @@ def on_validate(self) -> "Generator[None, None, None]":
                 parent_span=self.graphql_span,
                 name="validation",
             )
-            self.validation_span.set_op(OP.GRAPHQL_VALIDATE)
-            self.validation_span.set_origin(
+            self.validation_span.set_attribute("sentry.op", OP.GRAPHQL_VALIDATE)
+            self.validation_span.set_attribute(
+                "sentry.origin",
                 StrawberryIntegration.origin,
             )
         else:
@@ -268,8 +271,10 @@ def on_parse(self) -> "Generator[None, None, None]":
                 name="parsing",
                 parent_span=self.graphql_span,
             )
-            self.parsing_span.set_op(OP.GRAPHQL_PARSE)
-            self.parsing_span.set_origin(StrawberryIntegration.origin)
+            self.parsing_span.set_attribute("sentry.op", OP.GRAPHQL_PARSE)
+            self.parsing_span.set_attribute(
+                "sentry.origin", StrawberryIntegration.origin
+            )
         else:
             self.parsing_span = self.graphql_span.start_child(
                 op=OP.GRAPHQL_PARSE,
@@ -324,8 +329,8 @@ async def resolve(
             span = sentry_sdk.traces.start_span(
                 parent_span=self.graphql_span, name=f"resolving {field_path}"
             )
-            span.set_op(OP.GRAPHQL_RESOLVE)
-            span.set_origin(StrawberryIntegration.origin)
+            span.set_attribute("sentry.op", OP.GRAPHQL_RESOLVE)
+            span.set_attribute("sentry.origin", StrawberryIntegration.origin)
             span.set_attribute("graphql.field_name", info.field_name)
             span.set_attribute("graphql.parent_type", info.parent_type.name)
             span.set_attribute("graphql.field_path", field_path)
@@ -365,8 +370,8 @@ def resolve(
                 parent_span=self.graphql_span,
                 name=f"resolving {field_path}",
             )
-            span.set_op(OP.GRAPHQL_RESOLVE)
-            span.set_origin(StrawberryIntegration.origin)
+            span.set_attribute("sentry.op", OP.GRAPHQL_RESOLVE)
+            span.set_attribute("sentry.origin", StrawberryIntegration.origin)
             span.set_attribute("graphql.field_name", info.field_name)
             span.set_attribute("graphql.parent_type", info.parent_type.name)
             span.set_attribute("graphql.field_path", field_path)
diff --git a/sentry_sdk/scope.py b/sentry_sdk/scope.py
@@ -831,7 +831,9 @@ def set_transaction_name(self, name: str, source: "Optional[str]" = None) -> Non
             elif isinstance(self._span, StreamedSpan):
                 self._span.segment.set_name(name)
                 if source:
-                    self._span.segment.set_source(source)
+                    self._span.segment.set_attribute(
+                        "sentry.span.source", getattr(source, "value", source)
+                    )
 
             elif self._span.containing_transaction:
                 self._span.containing_transaction.name = name
diff --git a/sentry_sdk/traces.py b/sentry_sdk/traces.py
diff --git a/sentry_sdk/tracing_utils.py b/sentry_sdk/tracing_utils.py
diff --git a/tests/tracing/test_span_streaming.py b/tests/tracing/test_span_streaming.py
