uipath 2.0.12__tar.gz → 2.0.14__tar.gz

{uipath-2.0.12 → uipath-2.0.14}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: uipath
-Version: 2.0.12
+Version: 2.0.14
 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.0.12 → uipath-2.0.14}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "uipath"
-version = "2.0.12"
+version = "2.0.14"
 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.0.12 → uipath-2.0.14}/src/uipath/_cli/cli_run.py

@@ -115,9 +115,9 @@ def run(entrypoint: Optional[str], input: Optional[str], resume: bool) -> None:
 
     # Handle result from middleware
     if result.error_message:
-        click.echo(result.error_message)
+        click.echo(result.error_message, err=True)
         if result.should_include_stacktrace:
-            click.echo(traceback.format_exc())
+            click.echo(traceback.format_exc(), err=True)
         click.get_current_context().exit(1)
 
     if result.info_message:

uipath-2.0.14/src/uipath/tracing/__init__.py

@@ -0,0 +1,3 @@
+from ._traced import TracingManager, traced, wait_for_tracers  # noqa: D104
+
+__all__ = ["TracingManager", "traced", "wait_for_tracers"]

{uipath-2.0.12 → uipath-2.0.14}/src/uipath/tracing/_otel_exporters.py

@@ -1,7 +1,8 @@
 import json
 import logging
 import os
-from typing import Sequence
+import time
+from typing import Any, Dict, Sequence
 
 from httpx import Client
 from opentelemetry.sdk.trace import ReadableSpan
@@ -30,7 +31,7 @@ class LlmOpsHttpExporter(SpanExporter):
 
         self.http_client = Client(headers=self.headers)
 
-    def export(self, spans: Sequence[ReadableSpan]):
+    def export(self, spans: Sequence[ReadableSpan]) -> SpanExportResult:
         """Export spans to UiPath LLM Ops."""
         logger.debug(
             f"Exporting {len(spans)} spans to {self.base_url}/llmopstenant_/api/Traces/spans"
@@ -39,23 +40,42 @@ class LlmOpsHttpExporter(SpanExporter):
         span_list = [
             _SpanUtils.otel_span_to_uipath_span(span).to_dict() for span in spans
         ]
+        url = self._build_url(span_list)
 
-        trace_id = str(span_list[0]["TraceId"])
-        url = f"{self.base_url}/llmopstenant_/api/Traces/spans?traceId={trace_id}&source=Robots"
-
-        logger.debug("payload: ", json.dumps(span_list))
-
-        res = self.http_client.post(url, json=span_list)
+        logger.debug("Payload: %s", json.dumps(span_list))
 
-        if res.status_code == 200:
-            return SpanExportResult.SUCCESS
-        else:
-            return SpanExportResult.FAILURE
+        return self._send_with_retries(url, span_list)
 
     def force_flush(self, timeout_millis: int = 30000) -> bool:
         """Force flush the exporter."""
         return True
 
+    def _build_url(self, span_list: list[Dict[str, Any]]) -> str:
+        """Construct the URL for the API request."""
+        trace_id = str(span_list[0]["TraceId"])
+        return f"{self.base_url}/llmopstenant_/api/Traces/spans?traceId={trace_id}&source=Robots"
+
+    def _send_with_retries(
+        self, url: str, payload: list[Dict[str, Any]], max_retries: int = 4
+    ) -> SpanExportResult:
+        """Send the HTTP request with retry logic."""
+        for attempt in range(max_retries):
+            try:
+                response = self.http_client.post(url, json=payload)
+                if response.status_code == 200:
+                    return SpanExportResult.SUCCESS
+                else:
+                    logger.warning(
+                        f"Attempt {attempt + 1} failed with status code {response.status_code}: {response.text}"
+                    )
+            except Exception as e:
+                logger.error(f"Attempt {attempt + 1} failed with exception: {e}")
+
+            if attempt < max_retries - 1:
+                time.sleep(1.5**attempt)  # Exponential backoff
+
+        return SpanExportResult.FAILURE
+
     def _get_base_url(self) -> str:
         uipath_url = (
             os.environ.get("UIPATH_URL")

{uipath-2.0.12 → uipath-2.0.14}/src/uipath/tracing/_traced.py

@@ -1,8 +1,9 @@
+import importlib
 import inspect
 import json
 import logging
 from functools import wraps
-from typing import Any, Callable, Optional
+from typing import Any, Callable, List, Optional, Tuple
 
 from opentelemetry import trace
 from opentelemetry.sdk.trace import TracerProvider
@@ -18,9 +19,94 @@ trace.get_tracer_provider().add_span_processor(BatchSpanProcessor(LlmOpsHttpExpo
 tracer = trace.get_tracer(__name__)
 
 
-def wait_for_tracers():
-    """Wait for all tracers to finish."""
-    trace.get_tracer_provider().shutdown()  # type: ignore
+class TracingManager:
+    """Static utility class to manage tracing implementations and decorated functions."""
+
+    # Registry to track original functions, decorated functions, and their parameters
+    # Each entry is (original_func, decorated_func, params)
+    _traced_registry: List[Tuple[Callable[..., Any], Callable[..., Any], Any]] = []
+
+    # Custom tracer implementation
+    _custom_tracer_implementation = None
+
+    @classmethod
+    def get_custom_tracer_implementation(cls):
+        """Get the currently set custom tracer implementation."""
+        return cls._custom_tracer_implementation
+
+    @classmethod
+    def register_traced_function(cls, original_func, decorated_func, params):
+        """Register a function decorated with @traced and its parameters.
+
+        Args:
+            original_func: The original function before decoration
+            decorated_func: The function after decoration
+            params: The parameters used for tracing
+        """
+        cls._traced_registry.append((original_func, decorated_func, params))
+
+    @classmethod
+    def reapply_traced_decorator(cls, tracer_implementation):
+        """Reapply a different tracer implementation to all functions previously decorated with @traced.
+
+        Args:
+            tracer_implementation: A function that takes the same parameters as _opentelemetry_traced
+                                 and returns a decorator
+        """
+        cls._custom_tracer_implementation = tracer_implementation
+
+        # Work with a copy of the registry to avoid modifying it during iteration
+        registry_copy = cls._traced_registry.copy()
+
+        for original_func, decorated_func, params in registry_copy:
+            # Apply the new decorator with the same parameters
+            new_decorated_func = tracer_implementation(**params)(original_func)
+
+            logger.debug(
+                f"Reapplying decorator to {original_func.__name__}, from {decorated_func.__name__}"
+            )
+
+            # If this is a method on a class, we need to update the class
+            if hasattr(original_func, "__self__") and hasattr(
+                original_func, "__func__"
+            ):
+                setattr(
+                    original_func.__self__.__class__,
+                    original_func.__name__,
+                    new_decorated_func.__get__(
+                        original_func.__self__, original_func.__self__.__class__
+                    ),
+                )
+            else:
+                # Replace the function in its module
+                if hasattr(original_func, "__module__") and hasattr(
+                    original_func, "__qualname__"
+                ):
+                    try:
+                        module = importlib.import_module(original_func.__module__)
+                        parts = original_func.__qualname__.split(".")
+
+                        # Handle nested objects
+                        obj = module
+                        for part in parts[:-1]:
+                            obj = getattr(obj, part)
+
+                        setattr(obj, parts[-1], new_decorated_func)
+
+                        # Update the registry entry for this function
+                        # Find the index and replace with updated entry
+                        for i, (orig, _dec, _p) in enumerate(cls._traced_registry):
+                            if orig is original_func:
+                                cls._traced_registry[i] = (
+                                    original_func,
+                                    new_decorated_func,
+                                    params,
+                                )
+                                break
+                    except (ImportError, AttributeError) as e:
+                        # Log the error but continue processing other functions
+                        logger.warning(f"Error reapplying decorator: {e}")
+                        continue
 
 
 def _default_input_processor(inputs):
@@ -33,23 +119,9 @@ def _default_output_processor(outputs):
     return {"redacted": "Output data not logged for privacy/security"}
 
 
-class TracedDecoratorRegistry:
-    """Registry for tracing decorators."""
-
-    _decorators: dict[str, Any] = {}
-    _active_decorator = "opentelemetry"
-
-    @classmethod
-    def register_decorator(cls, name, decorator_factory):
-        """Register a decorator factory function with a name."""
-        cls._decorators[name] = decorator_factory
-        cls._active_decorator = name
-        return cls
-
-    @classmethod
-    def get_decorator(cls):
-        """Get the currently active decorator factory."""
-        return cls._decorators.get(cls._active_decorator)
+def wait_for_tracers():
+    """Wait for all tracers to finish."""
+    trace.get_tracer_provider().shutdown()  # type: ignore
 
 
 def _opentelemetry_traced(
@@ -58,6 +130,8 @@ def _opentelemetry_traced(
     input_processor: Optional[Callable[..., Any]] = None,
     output_processor: Optional[Callable[..., Any]] = None,
 ):
+    """Default tracer implementation using OpenTelemetry."""
+
     def decorator(func):
         @wraps(func)
         def sync_wrapper(*args, **kwargs):
@@ -78,9 +152,7 @@ def _opentelemetry_traced(
                 if input_processor is not None:
                     processed_inputs = input_processor(json.loads(inputs))
                     inputs = json.dumps(processed_inputs, default=str)
-
                 span.set_attribute("inputs", inputs)
-
                 try:
                     result = func(*args, **kwargs)
                     # Process output if processor is provided
@@ -115,9 +187,7 @@ def _opentelemetry_traced(
                 if input_processor is not None:
                     processed_inputs = input_processor(json.loads(inputs))
                     inputs = json.dumps(processed_inputs, default=str)
-
                 span.set_attribute("inputs", inputs)
-
                 try:
                     result = await func(*args, **kwargs)
                     # Process output if processor is provided
@@ -152,9 +222,7 @@ def _opentelemetry_traced(
                 if input_processor is not None:
                     processed_inputs = input_processor(json.loads(inputs))
                     inputs = json.dumps(processed_inputs, default=str)
-
                 span.set_attribute("inputs", inputs)
-
                 outputs = []
                 try:
                     for item in func(*args, **kwargs):
@@ -195,9 +263,7 @@ def _opentelemetry_traced(
                 if input_processor is not None:
                     processed_inputs = input_processor(json.loads(inputs))
                     inputs = json.dumps(processed_inputs, default=str)
-
                 span.set_attribute("inputs", inputs)
-
                 outputs = []
                 try:
                     async for item in func(*args, **kwargs):
@@ -254,16 +320,28 @@ def traced(
     # Apply default processors selectively based on hide flags
     if hide_input:
         input_processor = _default_input_processor
-
     if hide_output:
         output_processor = _default_output_processor
 
-    decorator_factory = TracedDecoratorRegistry.get_decorator()
+    # Store the parameters for later reapplication
+    params = {
+        "run_type": run_type,
+        "span_type": span_type,
+        "input_processor": input_processor,
+        "output_processor": output_processor,
+    }
 
-    if decorator_factory:
-        return decorator_factory(run_type, span_type, input_processor, output_processor)
-    else:
-        # Fallback to original implementation if no active decorator
-        return _opentelemetry_traced(
-            run_type, span_type, input_processor, output_processor
-        )
+    # Check for custom implementation first
+    custom_implementation = TracingManager.get_custom_tracer_implementation()
+    tracer_impl: Any = (
+        custom_implementation if custom_implementation else _opentelemetry_traced
+    )
+
+    def decorator(func):
+        # Decorate the function
+        decorated_func = tracer_impl(**params)(func)
+        # Register both original and decorated function with parameters
+        TracingManager.register_traced_function(func, decorated_func, params)
+        return decorated_func
+
+    return decorator

uipath-2.0.14/tests/tracing/test_otel_exporters.py

@@ -0,0 +1,190 @@
+import os
+from unittest.mock import MagicMock, patch
+
+import pytest
+from opentelemetry.sdk.trace import ReadableSpan
+from opentelemetry.sdk.trace.export import SpanExportResult
+
+from uipath.tracing._otel_exporters import LlmOpsHttpExporter
+
+
+@pytest.fixture
+def mock_env_vars():
+    """Fixture to set and clean up environment variables for testing."""
+    original_values = {}
+
+    # Save original values
+    for var in ["UIPATH_URL", "UIPATH_ACCESS_TOKEN"]:
+        original_values[var] = os.environ.get(var)
+
+    # Set test values
+    os.environ["UIPATH_URL"] = "https://test.uipath.com/org/tenant/"
+    os.environ["UIPATH_ACCESS_TOKEN"] = "test-token"
+
+    yield
+
+    # Restore original values
+    for var, value in original_values.items():
+        if value is None:
+            if var in os.environ:
+                del os.environ[var]
+        else:
+            os.environ[var] = value
+
+
+@pytest.fixture
+def mock_span():
+    """Create a mock ReadableSpan for testing."""
+    span = MagicMock(spec=ReadableSpan)
+    return span
+
+
+@pytest.fixture
+def exporter(mock_env_vars):
+    """Create an exporter instance for testing."""
+    with patch("uipath.tracing._otel_exporters.Client"):
+        exporter = LlmOpsHttpExporter()
+        # Mock _build_url to include query parameters as in the actual implementation
+        exporter._build_url = MagicMock(  # type: ignore
+            return_value="https://test.uipath.com/org/tenant/llmopstenant_/api/Traces/spans?traceId=test-trace-id&source=Robots"
+        )
+        yield exporter
+
+
+def test_init_with_env_vars(mock_env_vars):
+    """Test initialization with environment variables."""
+    with patch("uipath.tracing._otel_exporters.Client"):
+        exporter = LlmOpsHttpExporter()
+
+        assert exporter.base_url == "https://test.uipath.com/org/tenant"
+        assert exporter.auth_token == "test-token"
+        assert exporter.headers == {
+            "Content-Type": "application/json",
+            "Authorization": "Bearer test-token",
+        }
+
+
+def test_init_with_default_url():
+    """Test initialization with default URL when environment variable is not set."""
+    with (
+        patch("uipath.tracing._otel_exporters.Client"),
+        patch.dict(os.environ, {"UIPATH_ACCESS_TOKEN": "test-token"}, clear=True),
+    ):
+        exporter = LlmOpsHttpExporter()
+
+        assert exporter.base_url == "https://cloud.uipath.com/dummyOrg/dummyTennant"
+        assert exporter.auth_token == "test-token"
+
+
+def test_export_success(exporter, mock_span):
+    """Test successful export of spans."""
+    mock_uipath_span = MagicMock()
+    mock_uipath_span.to_dict.return_value = {"span": "data", "TraceId": "test-trace-id"}
+
+    with patch(
+        "uipath.tracing._otel_exporters._SpanUtils.otel_span_to_uipath_span",
+        return_value=mock_uipath_span,
+    ):
+        mock_response = MagicMock()
+        mock_response.status_code = 200
+        exporter.http_client.post.return_value = mock_response
+
+        result = exporter.export([mock_span])
+
+        assert result == SpanExportResult.SUCCESS
+        exporter._build_url.assert_called_once_with(
+            [{"span": "data", "TraceId": "test-trace-id"}]
+        )
+        exporter.http_client.post.assert_called_once_with(
+            "https://test.uipath.com/org/tenant/llmopstenant_/api/Traces/spans?traceId=test-trace-id&source=Robots",
+            json=[{"span": "data", "TraceId": "test-trace-id"}],
+        )
+
+
+def test_export_failure(exporter, mock_span):
+    """Test export failure with multiple retries."""
+    mock_uipath_span = MagicMock()
+    mock_uipath_span.to_dict.return_value = {"span": "data"}
+
+    with patch(
+        "uipath.tracing._otel_exporters._SpanUtils.otel_span_to_uipath_span",
+        return_value=mock_uipath_span,
+    ):
+        mock_response = MagicMock()
+        mock_response.status_code = 500
+        mock_response.text = "Internal Server Error"
+        exporter.http_client.post.return_value = mock_response
+
+        with patch("uipath.tracing._otel_exporters.time.sleep") as mock_sleep:
+            result = exporter.export([mock_span])
+
+        assert result == SpanExportResult.FAILURE
+        assert exporter.http_client.post.call_count == 4  # Default max_retries is 3
+        assert (
+            mock_sleep.call_count == 3
+        )  # Should sleep between retries (except after the last one)
+
+
+def test_export_exception(exporter, mock_span):
+    """Test export with exceptions during HTTP request."""
+    mock_uipath_span = MagicMock()
+    mock_uipath_span.to_dict.return_value = {"span": "data"}
+
+    with patch(
+        "uipath.tracing._otel_exporters._SpanUtils.otel_span_to_uipath_span",
+        return_value=mock_uipath_span,
+    ):
+        exporter.http_client.post.side_effect = Exception("Connection error")
+
+        with patch("uipath.tracing._otel_exporters.time.sleep"):
+            result = exporter.export([mock_span])
+
+        assert result == SpanExportResult.FAILURE
+        assert exporter.http_client.post.call_count == 4  # Default max_retries is 3
+
+
+def test_force_flush(exporter):
+    """Test force_flush returns True."""
+    assert exporter.force_flush() is True
+
+
+def test_get_base_url():
+    """Test _get_base_url method with different environment configurations."""
+    # Test with environment variable set
+    with patch.dict(
+        os.environ, {"UIPATH_URL": "https://custom.uipath.com/org/tenant/"}, clear=True
+    ):
+        with patch("uipath.tracing._otel_exporters.Client"):
+            exporter = LlmOpsHttpExporter()
+            assert exporter.base_url == "https://custom.uipath.com/org/tenant"
+
+    # Test with environment variable set but with no trailing slash
+    with patch.dict(
+        os.environ, {"UIPATH_URL": "https://custom.uipath.com/org/tenant"}, clear=True
+    ):
+        with patch("uipath.tracing._otel_exporters.Client"):
+            exporter = LlmOpsHttpExporter()
+            assert exporter.base_url == "https://custom.uipath.com/org/tenant"
+
+    # Test with no environment variable
+    with patch.dict(os.environ, {}, clear=True):
+        with patch("uipath.tracing._otel_exporters.Client"):
+            exporter = LlmOpsHttpExporter()
+            assert exporter.base_url == "https://cloud.uipath.com/dummyOrg/dummyTennant"
+
+
+def test_send_with_retries_success():
+    """Test _send_with_retries method with successful response."""
+    with patch("uipath.tracing._otel_exporters.Client"):
+        exporter = LlmOpsHttpExporter()
+
+        mock_response = MagicMock()
+        mock_response.status_code = 200
+        exporter.http_client.post.return_value = mock_response  # type: ignore
+
+        result = exporter._send_with_retries("http://example.com", [{"span": "data"}])
+
+        assert result == SpanExportResult.SUCCESS
+        exporter.http_client.post.assert_called_once_with(  # type: ignore
+            "http://example.com", json=[{"span": "data"}]
+        )

uipath-2.0.14/tests/tracing/test_tracing_manager.py

@@ -0,0 +1,165 @@
+from functools import wraps
+
+from uipath.tracing._traced import TracingManager, traced
+
+
+# Custom wrapper that does nothing
+def donothing_custom_tracer(**kwargs):
+    def decorator(func):
+        @wraps(func)
+        def wrapper(*args, **kwargs):
+            # Simple implementation that just adds a marker to the result
+            result = func(*args, **kwargs)
+            return result
+
+        return wrapper
+
+    return decorator
+
+
+# Helper function for testing custom tracer
+def simple_custom_tracer(**kwargs):
+    def decorator(func):
+        @wraps(func)
+        def wrapper(*args, **kwargs):
+            # Simple implementation that just adds a marker to the result
+            result = func(*args, **kwargs)
+            if isinstance(result, dict):
+                result["custom_tracer_used"] = True
+            return result
+
+        return wrapper
+
+    return decorator
+
+
+# Helper function for testing custom tracer with method
+def custom_method_tracer(**kwargs):
+    def decorator(func):
+        @wraps(func)
+        def wrapper(*args, **kwargs):
+            result = func(*args, **kwargs)
+            if isinstance(result, dict):
+                result["custom_method_tracer_used"] = True
+            return result
+
+        return wrapper
+
+    return decorator
+
+
+# Helper function for testing with counter
+def custom_tracer_with_counter(call_counter, **kwargs):
+    def decorator(func):
+        @wraps(func)
+        def wrapper(*args, **kwargs):
+            call_counter["count"] += 1
+            result = func(*args, **kwargs)
+            if isinstance(result, dict):
+                result["custom_tracer_id"] = call_counter["count"]
+            return result
+
+        return wrapper
+
+    return decorator
+
+
+# Define the test classes
+class TestClassForMethodTest:
+    @traced()
+    def sample_method(self, x, y):
+        return {"product": x * y}
+
+
+# Module level functions for function test
+@traced()
+def func1_for_test(x):
+    return {"result": x * 2}
+
+
+@traced()
+def func2_for_test(x):
+    return {"result": x * 3}
+
+
+# Define a function with @traced
+@traced()
+def sample_function():
+    return {"status": "success"}
+
+
+def test_tracing_manager_custom_implementation():
+    """Test setting and getting a custom tracer implementation."""
+    # Set the custom implementation
+    TracingManager.reapply_traced_decorator(simple_custom_tracer)
+
+    # Get the implementation and verify it's the same one
+    impl = TracingManager.get_custom_tracer_implementation()
+    assert impl is simple_custom_tracer
+
+
+def test_traced_with_custom_implementation():
+    """Test that @traced uses a custom implementation when provided."""
+    # Set the custom implementation
+    TracingManager.reapply_traced_decorator(simple_custom_tracer)
+
+    # Call the function and verify the custom implementation was used
+    result = sample_function()
+    assert "custom_tracer_used" in result
+    assert result["custom_tracer_used"] is True
+
+
+def test_reapply_traced_decorator_to_class_method():
+    """Test reapply_traced_decorator with class methods."""
+    TracingManager.reapply_traced_decorator(donothing_custom_tracer)
+
+    # Create instance and call with default implementation
+    instance = TestClassForMethodTest()
+    result1 = instance.sample_method(2, 3)
+    assert result1 == {"product": 6}
+
+    # Apply our custom implementation
+    TracingManager.reapply_traced_decorator(custom_method_tracer)
+
+    # Create a NEW instance which will use the updated class method
+    new_instance = TestClassForMethodTest()
+    result2 = new_instance.sample_method(2, 3)
+
+    # Verify the result
+    assert "product" in result2
+    assert result2["product"] == 6
+    assert "custom_method_tracer_used" in result2
+
+
+def test_reapply_to_module_level_functions():
+    """Test reapply_traced_decorator with module level functions."""
+
+    TracingManager.reapply_traced_decorator(donothing_custom_tracer)
+
+    # First call with default implementation
+    assert func1_for_test(5) == {"result": 10}
+    assert func2_for_test(5) == {"result": 15}
+
+    # Counter to track custom tracer calls
+    call_counter = {"count": 0}
+
+    # Reapply with the custom implementation
+    TracingManager.reapply_traced_decorator(
+        lambda **kwargs: custom_tracer_with_counter(call_counter, **kwargs)
+    )
+
+    # Call the functions directly - they should now use the updated implementation
+    result1 = func1_for_test(5)
+    result2 = func2_for_test(5)
+
+    # Verify the custom implementation was applied
+    assert "result" in result1
+    assert result1["result"] == 10
+    assert "custom_tracer_id" in result1
+
+    assert "result" in result2
+    assert result2["result"] == 15
+    assert "custom_tracer_id" in result2
+
+    # Verify both functions were processed
+    assert call_counter["count"] == 2