rename and wip

Author: sentrivana

sentry_sdk/api.py

@@ -341,7 +341,7 @@ def flush(
 
 def start_span(
     *,
-    segment_span=None,
+    root_span=None,
     custom_sampling_context=None,
     **kwargs,  # type: Any
 ):
@@ -351,12 +351,11 @@ def start_span(
     """
     # TODO: Consider adding type hints to the method signature.
     return get_current_scope().start_span(
-        segment_span, custom_sampling_context, **kwargs
+        root_span, custom_sampling_context, **kwargs
     )
 
 
 def start_transaction(
-    *,
     transaction=None,  # type: Optional[Span]
     custom_sampling_context=None,  # type: Optional[SamplingContext]
     **kwargs,  # type: Unpack[TransactionKwargs]
@@ -396,7 +395,7 @@ def start_transaction(
         available arguments.
     """
     return get_current_scope().start_span(
-        segment_span=transaction,
+        root_span=transaction,
         custom_sampling_context=custom_sampling_context,
         **kwargs,
     )

sentry_sdk/integrations/opentelemetry/potel_span_processor.py

@@ -53,7 +53,7 @@ def on_end(self, span):
             self._children_spans[span.parent.span_id].append(span)
         else:
             # if have a root span ending, we build a transaction and send it
-            self._flush_segment_span(span)
+            self._flush_root_span(span)
 
     # TODO-neel-potel not sure we need a clear like JS
     def shutdown(self):
@@ -66,9 +66,9 @@ def force_flush(self, timeout_millis=30000):
         # type: (int) -> bool
         return True
 
-    def _flush_segment_span(self, span):
+    def _flush_root_span(self, span):
         # type: (ReadableSpan) -> None
-        transaction_event = self._segment_span_to_transaction_event(span)
+        transaction_event = self._root_span_to_transaction_event(span)
         if not transaction_event:
             return
 
@@ -103,7 +103,7 @@ def _collect_children(self, span):
 
     # we construct the event from scratch here
     # and not use the current Transaction class for easier refactoring
-    def _segment_span_to_transaction_event(self, span):
+    def _root_span_to_transaction_event(self, span):
         # type: (ReadableSpan) -> Optional[Event]
         if not span.context:
             return None

sentry_sdk/integrations/wsgi.py

@@ -93,7 +93,7 @@ def __call__(self, environ, start_response):
                             )
                         )
 
-                    segment_span = continue_trace(
+                    root_span = continue_trace(
                         environ,
                         op=OP.HTTP_SERVER,
                         name="generic WSGI request",
@@ -102,13 +102,13 @@ def __call__(self, environ, start_response):
                     )
 
                     with sentry_sdk.start_transaction(
-                        segment_span, custom_sampling_context={"wsgi_environ": environ}
+                        root_span, custom_sampling_context={"wsgi_environ": environ}
                     ):
                         try:
                             response = self.app(
                                 environ,
                                 partial(
-                                    _sentry_start_response, start_response, segment_span
+                                    _sentry_start_response, start_response, root_span
                                 ),
                             )
                         except BaseException:

sentry_sdk/scope.py

@@ -165,8 +165,8 @@ class Scope(object):
         "_level",
         "_name",
         "_fingerprint",
-        "_segment_span_name",
-        "_segment_span_info",
+        "_root_span_name",
+        "_root_span_info",
         "_user",
         "_tags",
         "_contexts",
@@ -218,8 +218,8 @@ def __copy__(self):
         rv._level = self._level
         rv._name = self._name
         rv._fingerprint = self._fingerprint
-        rv._segment_span_name = self._segment_span_name
-        rv._segment_span_info = dict(self._segment_span_info)
+        rv._root_span_name = self._root_span_name
+        rv._root_span_info = dict(self._root_span_info)
         rv._user = self._user
 
         rv._tags = dict(self._tags)
@@ -669,8 +669,8 @@ def clear(self):
         """Clears the entire scope."""
         self._level = None  # type: Optional[LogLevelStr]
         self._fingerprint = None  # type: Optional[List[str]]
-        self._segment_span_name = None  # type: Optional[str]
-        self._segment_span_info = {}  # type: MutableMapping[str, str]
+        self._root_span_name = None  # type: Optional[str]
+        self._root_span_info = {}  # type: MutableMapping[str, str]
         self._user = None  # type: Optional[Dict[str, Any]]
 
         self._tags = {}  # type: Dict[str, Any]
@@ -715,49 +715,49 @@ def transaction(self):
         Return the transaction in the scope, if any.
 
         .. deprecated:: 3.0.0
-            This function is deprecated and will be removed in a future release. Use Scope.segment_span instead.
+            This function is deprecated and will be removed in a future release. Use Scope.root_span instead.
         """
 
         logger.warning(
-            "Deprecated: use Scope.segment_span instead. This will be removed in the future."
+            "Deprecated: use Scope.root_span instead. This will be removed in the future."
         )
 
-        return self.segment_span
+        return self.root_span
 
     @property
-    def segment_span(self):
+    def root_span(self):
         """Return the root span in the scope, if any."""
         # there is no span/transaction on the scope
         if self._span is None:
             return None
 
         # there is an orphan span on the scope
-        if self._span.segment_span is None:
+        if self._span.root_span is None:
             return None
 
         # there is either a root span (which is its own containing
         # root span) or a non-orphan span on the scope
-        return self._span.segment_span
+        return self._span.root_span
 
     def set_transaction_name(self, name, source=None):
         # type: (str, Optional[str]) -> None
         """
         Set the transaction name and optionally the transaction source.
 
         .. deprecated:: 3.0.0
-            This function is deprecated and will be removed in a future release. Use Scope.set_segment_span_name instead.
+            This function is deprecated and will be removed in a future release. Use Scope.set_root_span_name instead.
         """
-        self.set_segment_span_name(name, source)
+        self.set_root_span_name(name, source)
 
-    def set_segment_span_name(self, name, source=None):
+    def set_root_span_name(self, name, source=None):
         """Set the root span name and optionally the source."""
-        self._segment_span_name = name
-        if self._span and self._span.segment_span:
-            self._span.segment_span.name = name
+        self._root_span_name = name
+        if self._span and self._span.root_span:
+            self._span.root_span.name = name
             if source:
-                self._span.segment_span.source = source
+                self._span.root_span.source = source
         if source:
-            self._segment_span_info["source"] = source
+            self._root_span_info["source"] = source
 
     @_attr_setter
     def user(self, value):
@@ -789,9 +789,9 @@ def span(self, span):
         return
         if span.is_segment:
             if span.name:
-                self._segment_span_name = span.name
+                self._root_span_name = span.name
                 if span.source:
-                    self._segment_span_info["source"] = span.source
+                    self._root_span_info["source"] = span.source
 
     @property
     def profile(self):
@@ -1016,7 +1016,7 @@ def start_transaction(
 
         return span
 
-    def start_span(self, segment_span=None, custom_sampling_context=None, **kwargs):
+    def start_span(self, root_span=None, custom_sampling_context=None, **kwargs):
         # type: (Optional[Span], Optional[SamplingContext], Any) -> Span
         """
         Start a span whose parent is the currently active span or transaction, if any.
@@ -1028,8 +1028,8 @@ def start_span(self, segment_span=None, custom_sampling_context=None, **kwargs):
         For supported `**kwargs` see :py:class:`sentry_sdk.tracing.Span`.
         """
         kwargs.setdefault("scope", self)
-        if segment_span:
-            return segment_span
+        if root_span:
+            return root_span
 
         span = self.span or self.get_isolation_scope().span
 
@@ -1073,15 +1073,15 @@ def continue_trace(
         """
         self.generate_propagation_context(environ_or_headers)
 
-        segment_span = Span.continue_from_headers(
+        root_span = Span.continue_from_headers(
             normalize_incoming_data(environ_or_headers),
             op=op,
             origin=origin,
             name=name,
             source=source,
         )
 
-        return segment_span
+        return root_span
 
     def capture_event(self, event, hint=None, scope=None, **scope_kwargs):
         # type: (Event, Optional[Hint], Optional[Scope], Any) -> Optional[str]
@@ -1276,18 +1276,18 @@ def _apply_user_to_event(self, event, hint, options):
         if event.get("user") is None and self._user is not None:
             event["user"] = self._user
 
-    def _apply_segment_span_name_to_event(self, event, hint, options):
+    def _apply_root_span_name_to_event(self, event, hint, options):
         # type: (Event, Hint, Optional[Dict[str, Any]]) -> None
-        if event.get("transaction") is None and self._segment_span_name is not None:
-            event["transaction"] = self._segment_span_name
+        if event.get("transaction") is None and self._root_span_name is not None:
+            event["transaction"] = self._root_span_name
 
-    def _apply_segment_span_info_to_event(self, event, hint, options):
+    def _apply_root_span_info_to_event(self, event, hint, options):
         # type: (Event, Hint, Optional[Dict[str, Any]]) -> None
         if (
             event.get("transaction_info") is None
-            and self._segment_span_info is not None
+            and self._root_span_info is not None
         ):
-            event["transaction_info"] = self._segment_span_info
+            event["transaction_info"] = self._root_span_info
 
     def _apply_fingerprint_to_event(self, event, hint, options):
         # type: (Event, Hint, Optional[Dict[str, Any]]) -> None
@@ -1409,8 +1409,8 @@ def apply_to_event(
             self._apply_level_to_event(event, hint, options)
             self._apply_fingerprint_to_event(event, hint, options)
             self._apply_user_to_event(event, hint, options)
-            self._apply_segment_span_name_to_event(event, hint, options)
-            self._apply_segment_span_info_to_event(event, hint, options)
+            self._apply_root_span_name_to_event(event, hint, options)
+            self._apply_root_span_info_to_event(event, hint, options)
             self._apply_tags_to_event(event, hint, options)
             self._apply_extra_to_event(event, hint, options)
 
@@ -1434,10 +1434,10 @@ def update_from_scope(self, scope):
             self._level = scope._level
         if scope._fingerprint is not None:
             self._fingerprint = scope._fingerprint
-        if scope._segment_span_name is not None:
-            self._segment_span_name = scope._segment_span_name
-        if scope._segment_span_info is not None:
-            self._segment_span_info.update(scope._segment_span_info)
+        if scope._root_span_name is not None:
+            self._root_span_name = scope._root_span_name
+        if scope._root_span_info is not None:
+            self._root_span_info.update(scope._root_span_info)
         if scope._user is not None:
             self._user = scope._user
         if scope._tags:

sentry_sdk/tracing.py

@@ -1253,7 +1253,7 @@ def origin(self, value):
             self._otel_span.set_attribute(SentrySpanAttribute.ORIGIN, value)
 
     @property
-    def segment_span(self):
+    def root_span(self):
         if isinstance(self._otel_span, otel_trace.NonRecordingSpan):
             return None
 
@@ -1285,7 +1285,7 @@ def containing_transaction(self):
         """
 
         logger.warning("Deprecated: This will be removed in the future.")
-        return self.segment_span
+        return self.root_span
 
     @containing_transaction.setter
     def containing_transaction(self, value):
@@ -1294,7 +1294,7 @@ def containing_transaction(self, value):
         Set this span's transaction.
 
         .. deprecated:: 3.0.0
-            Use :func:`segment_span` instead.
+            Use :func:`root_span` instead.
         """
         pass