alter traces

Author: ionmincu

src/uipath/core/tracing/manager.py

@@ -28,33 +28,92 @@ def register_current_span_provider(
         cls._current_span_provider = current_span_provider
 
     @staticmethod
-    def get_parent_context():
+    def get_parent_context() -> context.Context:
         """Get the parent context for span creation.
 
         Prioritizes:
-        1. Currently active OTel span (for recursion/children)
-        2. External span provider (for top-level calls)
-        3. Current context as fallback
+        - Bottom-most span when both current_span and external_span exist
+        - Single available span (current_span or external_span)
+        - Current context as fallback
         """
-        # Always use the currently active OTel span if valid (recursion / children)
         current_span = trace.get_current_span()
+        has_current_span = current_span is not None and current_span.get_span_context().is_valid
 
-        if current_span is not None and current_span.get_span_context().is_valid:
+        external_span = UiPathTracingManager.get_external_current_span()
+        has_external_span = external_span is not None
+
+        # Only one or no spans available
+        if not has_current_span:
+            return set_span_in_context(external_span) if has_external_span else context.get_current()
+        if not has_external_span:
             return set_span_in_context(current_span)
 
-        # Only for the very top-level call, fallback to external span provider
+        # Both spans exist - find the bottom-most one
+        bottom_span = UiPathTracingManager._get_bottom_most_span(
+            current_span, external_span
+        )
+        return set_span_in_context(bottom_span)
+
+    @staticmethod
+    def _get_bottom_most_span(current_span: Any, external_span: Any) -> Any:
+        """Determine which span is deeper in the ancestor tree.
+
+        Args:
+            current_span: The OTel current span
+            external_span: The external span from the provider
+
+        Returns:
+            The span that is deeper (closer to the bottom) in the call hierarchy
+        """
+        ancestor_spans = UiPathTracingManager.get_ancestor_spans()
+        if not ancestor_spans:
+            return external_span
+
+        current_span_id = current_span.get_span_context().span_id
+        external_span_id = external_span.get_span_context().span_id
+
+        current_index = None
+        external_index = None
+
+        for i, ancestor in enumerate(ancestor_spans):
+            ancestor_id = ancestor.get_span_context().span_id
+            if ancestor_id == current_span_id:
+                current_index = i
+            if ancestor_id == external_span_id:
+                external_index = i
+
+        # Both in tree: higher index = deeper
+        if current_index is not None and external_index is not None:
+            return current_span if current_index > external_index else external_span
+
+        # Only one in tree: that one is deeper
+        if current_index is not None:
+            return current_span
+        if external_index is not None:
+            return external_span
+
+        # Neither in tree: default to external
+        return external_span
+
+    @staticmethod
+    def get_external_current_span():
+        """Get the current span from the external provider, if any."""
         if UiPathTracingManager._current_span_provider is not None:
             try:
-                external_span = UiPathTracingManager._current_span_provider()
-                if external_span is not None:
-                    return set_span_in_context(external_span)
+                return UiPathTracingManager._current_span_provider()
             except Exception as e:
                 logger.warning(f"Error getting current span from provider: {e}")
+        return None
 
-        # Last fallback
-        ctx = context.get_current()
-
-        return ctx
+    @classmethod
+    def get_ancestor_spans(cls) -> List[Any]:
+        """Get the ancestor spans from the registered provider, if any."""
+        if cls._current_span_ancestors_provider is not None:
+            try:
+                return cls._current_span_ancestors_provider()
+            except Exception as e:
+                logger.warning(f"Error getting ancestor spans from provider: {e}")
+        return []
 
     @classmethod
     def register_current_span_ancestors_provider(