uipath 2.0.12__tar.gz → 2.0.13__tar.gz

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

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

@@ -1,6 +1,6 @@
 [project]
 name = "uipath"
-version = "2.0.12"
+version = "2.0.13"
 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.13}/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.13/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.12 → uipath-2.0.13}/uv.lock

@@ -2393,7 +2393,7 @@ wheels = [
 
 [[package]]
 name = "uipath"
-version = "2.0.12"
+version = "2.0.13"
 source = { editable = "." }
 dependencies = [
     { name = "click" },