uipath 2.1.121__tar.gz → 2.1.122__tar.gz

{uipath-2.1.121 → uipath-2.1.122}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: uipath
-Version: 2.1.121
+Version: 2.1.122
 Summary: Python SDK and CLI for UiPath Platform, enabling programmatic interaction with automation services, process management, and deployment tools.
 Project-URL: Homepage, https://uipath.com
 Project-URL: Repository, https://github.com/UiPath/uipath-python

{uipath-2.1.121 → uipath-2.1.122}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "uipath"
-version = "2.1.121"
+version = "2.1.122"
 description = "Python SDK and CLI for UiPath Platform, enabling programmatic interaction with automation services, process management, and deployment tools."
 readme = { file = "README.md", content-type = "text/markdown" }
 requires-python = ">=3.10"

{uipath-2.1.121 → uipath-2.1.122}/src/uipath/_cli/_evals/mocks/input_mocker.py

@@ -52,7 +52,7 @@ Based on the above information, provide a realistic input to the LLM agent. Your
 OUTPUT: ONLY the simulated agent input in the exact format of the INPUT_SCHEMA in valid JSON. Do not include any explanations, quotation marks, or markdown."""
 
 
-@traced(name="__mocker__")
+@traced(name="__mocker__", recording=False)
 async def generate_llm_input(
     evaluation_item: AnyEvaluationItem,
     input_schema: Dict[str, Any],

{uipath-2.1.121 → uipath-2.1.122}/src/uipath/_cli/_evals/mocks/llm_mocker.py

@@ -82,7 +82,7 @@ class LLMMocker(Mocker):
         self.evaluation_item = evaluation_item
         assert isinstance(self.evaluation_item.mocking_strategy, LLMMockingStrategy)
 
-    @traced(name="__mocker__")
+    @traced(name="__mocker__", recording=False)
     async def response(
         self, func: Callable[[T], R], params: dict[str, Any], *args: T, **kwargs
     ) -> R:

{uipath-2.1.121 → uipath-2.1.122}/src/uipath/tracing/_traced.py

@@ -7,7 +7,7 @@ from functools import wraps
 from typing import Any, Callable, List, Optional, Tuple
 
 from opentelemetry import context, trace
-from opentelemetry.trace import set_span_in_context
+from opentelemetry.trace import NonRecordingSpan, set_span_in_context
 
 from ._utils import _SpanUtils
 
@@ -175,6 +175,7 @@ def _opentelemetry_traced(
     span_type: Optional[str] = None,
     input_processor: Optional[Callable[..., Any]] = None,
     output_processor: Optional[Callable[..., Any]] = None,
+    recording: bool = True,
 ):
     """Default tracer implementation using OpenTelemetry."""
 
@@ -184,7 +185,10 @@ def _opentelemetry_traced(
         def get_parent_context():
             """Return a context object for starting the new span."""
             current_span = _active_traced_span.get()
-            if 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
+                or isinstance(current_span, NonRecordingSpan)
+            ):
                 return set_span_in_context(current_span)
 
             if TracingManager._current_span_provider is not None:
@@ -197,12 +201,22 @@ def _opentelemetry_traced(
 
             return context.get_current()
 
+        def get_span():
+            if recording and not isinstance(
+                _active_traced_span.get(), NonRecordingSpan
+            ):
+                ctx = get_parent_context()
+                span_cm = get_tracer().start_as_current_span(trace_name, context=ctx)
+                span = span_cm.__enter__()
+            else:
+                span_cm = None
+                span = NonRecordingSpan(trace.INVALID_SPAN_CONTEXT)
+            return span_cm, span
+
         # --------- Sync wrapper ---------
         @wraps(func)
         def sync_wrapper(*args, **kwargs):
-            ctx = get_parent_context()
-            span_cm = get_tracer().start_as_current_span(trace_name, context=ctx)
-            span = span_cm.__enter__()
+            span_cm, span = get_span()
             token = _active_traced_span.set(span)
             try:
                 span.set_attribute("span_type", span_type or "function_call_sync")
@@ -241,14 +255,13 @@ def _opentelemetry_traced(
                 raise
             finally:
                 _active_traced_span.reset(token)
-                span_cm.__exit__(None, None, None)
+                if span_cm:
+                    span_cm.__exit__(None, None, None)
 
         # --------- Async wrapper ---------
         @wraps(func)
         async def async_wrapper(*args, **kwargs):
-            ctx = get_parent_context()
-            span_cm = get_tracer().start_as_current_span(trace_name, context=ctx)
-            span = span_cm.__enter__()
+            span_cm, span = get_span()
             token = _active_traced_span.set(span)
             try:
                 span.set_attribute("span_type", span_type or "function_call_async")
@@ -287,14 +300,13 @@ def _opentelemetry_traced(
                 raise
             finally:
                 _active_traced_span.reset(token)
-                span_cm.__exit__(None, None, None)
+                if span_cm:
+                    span_cm.__exit__(None, None, None)
 
         # --------- Generator wrapper ---------
         @wraps(func)
         def generator_wrapper(*args, **kwargs):
-            ctx = get_parent_context()
-            span_cm = get_tracer().start_as_current_span(trace_name, context=ctx)
-            span = span_cm.__enter__()
+            span_cm, span = get_span()
             token = _active_traced_span.set(span)
             try:
                 span.set_attribute(
@@ -330,14 +342,13 @@ def _opentelemetry_traced(
                 raise
             finally:
                 _active_traced_span.reset(token)
-                span_cm.__exit__(None, None, None)
+                if span_cm:
+                    span_cm.__exit__(None, None, None)
 
         # --------- Async generator wrapper ---------
         @wraps(func)
         async def async_generator_wrapper(*args, **kwargs):
-            ctx = get_parent_context()
-            span_cm = get_tracer().start_as_current_span(trace_name, context=ctx)
-            span = span_cm.__enter__()
+            span_cm, span = get_span()
             token = _active_traced_span.set(span)
             try:
                 span.set_attribute(
@@ -373,7 +384,8 @@ def _opentelemetry_traced(
                 raise
             finally:
                 _active_traced_span.reset(token)
-                span_cm.__exit__(None, None, None)
+                if span_cm:
+                    span_cm.__exit__(None, None, None)
 
         if inspect.iscoroutinefunction(func):
             return async_wrapper
@@ -425,6 +437,7 @@ def traced(
     output_processor: Optional[Callable[..., Any]] = None,
     hide_input: bool = False,
     hide_output: bool = False,
+    recording: bool = True,
 ):
     """Decorator that will trace function invocations.
 
@@ -437,6 +450,7 @@ def traced(
             Should accept the function output and return a processed value
         hide_input: If True, don't log any input data
         hide_output: If True, don't log any output data
+        recording: If False, current span and all child spans are not captured regardless of their recording status.
     """
     # Apply default processors selectively based on hide flags
     if hide_input:
@@ -451,6 +465,7 @@ def traced(
         "span_type": span_type,
         "input_processor": input_processor,
         "output_processor": output_processor,
+        "recording": recording,
     }
 
     # Check for custom implementation first

{uipath-2.1.121 → uipath-2.1.122}/src/uipath/tracing/_utils.py

@@ -364,34 +364,12 @@ class _SpanUtils:
             )
             return {"args": args, "kwargs": kwargs}
 
-    @staticmethod
-    def _has_ancestor_with_name(
-        span: ReadableSpan, ancestor_name: str, span_map: Dict[int, ReadableSpan]
-    ) -> bool:
-        """Check if this span or any of its ancestors has a given name."""
-        if span.name == ancestor_name:
-            return True
-
-        current = span
-        while current.parent is not None:
-            parent_span = span_map.get(current.parent.span_id)
-            if parent_span is None:
-                break
-            if parent_span.name == ancestor_name:
-                return True
-            current = parent_span
-
-        return False
-
     @staticmethod
     def spans_to_llm_context(spans: list[ReadableSpan]) -> str:
         """Convert spans to a formatted conversation history string suitable for LLM context.
 
         Includes function calls (including LLM calls) with their inputs and outputs.
         """
-        # Build span_id -> span map for parent chain traversal
-        span_map = {span.get_span_context().span_id: span for span in spans}
-
         history = []
         for span in spans:
             attributes = dict(span.attributes) if span.attributes else {}
@@ -402,10 +380,6 @@ class _SpanUtils:
             if not input_value or not output_value:
                 continue
 
-            # Skip spans that are internal LLM calls (eg. for tool mocking in evals)
-            if _SpanUtils._has_ancestor_with_name(span, "__mocker__", span_map):
-                continue
-
             history.append(f"Function: {span.name}")
             history.append(f"Input: {input_value}")
             history.append(f"Output: {output_value}")

{uipath-2.1.121 → uipath-2.1.122}/tests/tracing/test_traced.py

@@ -728,3 +728,91 @@ async def test_traced_with_pydantic_basemodel_class(setup_tracer):
 
     assert "choices" in output
     assert len(output["choices"]) == 1
+
+
+@pytest.mark.asyncio
+async def test_non_recording_traced_async_function(setup_tracer):
+    exporter, provider = setup_tracer
+
+    @traced(recording=True)
+    async def child_sample_async_function(x, y):
+        return x * y
+
+    @traced(recording=False)
+    async def sample_async_function(x, y):
+        return await child_sample_async_function(x, y)
+
+    result = await sample_async_function(2, 3)
+    assert result == 6
+
+    provider.shutdown()  # Ensure spans are flushed
+
+    await sleep(1)
+    spans = exporter.get_exported_spans()
+
+    assert len(spans) == 0
+
+
+def test_non_recording_traced_sync_function(setup_tracer):
+    exporter, provider = setup_tracer
+
+    @traced(recording=True)
+    def child_sample_sync_function(x, y):
+        return x * y
+
+    @traced(recording=False)
+    def sample_sync_function(x, y):
+        return child_sample_sync_function(x, y)
+
+    result = sample_sync_function(2, 3)
+    assert result == 6
+
+    provider.shutdown()  # Ensure spans are flushed
+    spans = exporter.get_exported_spans()
+
+    assert len(spans) == 0
+
+
+def test_non_recording_traced_generator_function(setup_tracer):
+    exporter, provider = setup_tracer
+
+    @traced()
+    def sample_child_generator_function(n):
+        for i in range(n):
+            yield i
+
+    @traced(recording=False)
+    def sample_generator_function(n):
+        for i in sample_child_generator_function(n):
+            yield i
+
+    results = list(sample_generator_function(3))
+    assert results == [0, 1, 2]
+
+    provider.shutdown()  # Ensure spans are flushed
+    spans = exporter.get_exported_spans()
+
+    assert len(spans) == 0
+
+
+@pytest.mark.asyncio
+async def test_non_recording_traced_async_generator_function(setup_tracer):
+    exporter, provider = setup_tracer
+
+    @traced()
+    async def sample_child_async_generator_function(n):
+        for i in range(n):
+            yield i
+
+    @traced(recording=False)
+    async def sample_async_generator_function(n):
+        async for i in sample_child_async_generator_function(n):
+            yield i
+
+    results = [item async for item in sample_async_generator_function(3)]
+    assert results == [0, 1, 2]
+
+    provider.shutdown()  # Ensure spans are flushed
+    spans = exporter.get_exported_spans()
+
+    assert len(spans) == 0

{uipath-2.1.121 → uipath-2.1.122}/uv.lock

@@ -3047,7 +3047,7 @@ wheels = [
 
 [[package]]
 name = "uipath"
-version = "2.1.121"
+version = "2.1.122"
 source = { editable = "." }
 dependencies = [
     { name = "azure-monitor-opentelemetry" },