uipath 2.1.57__tar.gz → 2.1.58__tar.gz

{uipath-2.1.57 → uipath-2.1.58}/PKG-INFO

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

@@ -1,6 +1,6 @@
 [project]
 name = "uipath"
-version = "2.1.57"
+version = "2.1.58"
 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.57 → uipath-2.1.58}/src/uipath/tracing/_traced.py

@@ -215,11 +215,15 @@ def _opentelemetry_traced(
                 if input_processor:
                     processed_inputs = input_processor(json.loads(inputs))
                     inputs = json.dumps(processed_inputs, default=str)
-                span.set_attribute("inputs", inputs)
+                span.set_attribute("input.mime_type", "application/json")
+                span.set_attribute("input.value", inputs)
 
                 result = func(*args, **kwargs)
                 output = output_processor(result) if output_processor else result
-                span.set_attribute("output", json.dumps(output, default=str))
+                span.set_attribute(
+                    "output.value", _SpanUtils.format_object_for_trace_json(output)
+                )
+                span.set_attribute("output.mime_type", "application/json")
                 return result
             except Exception as e:
                 span.record_exception(e)
@@ -249,11 +253,15 @@ def _opentelemetry_traced(
                 if input_processor:
                     processed_inputs = input_processor(json.loads(inputs))
                     inputs = json.dumps(processed_inputs, default=str)
-                span.set_attribute("inputs", inputs)
+                span.set_attribute("input.mime_type", "application/json")
+                span.set_attribute("input.value", inputs)
 
                 result = await func(*args, **kwargs)
                 output = output_processor(result) if output_processor else result
-                span.set_attribute("output", json.dumps(output, default=str))
+                span.set_attribute(
+                    "output.value", _SpanUtils.format_object_for_trace_json(output)
+                )
+                span.set_attribute("output.mime_type", "application/json")
                 return result
             except Exception as e:
                 span.record_exception(e)
@@ -285,7 +293,8 @@ def _opentelemetry_traced(
                 if input_processor:
                     processed_inputs = input_processor(json.loads(inputs))
                     inputs = json.dumps(processed_inputs, default=str)
-                span.set_attribute("inputs", inputs)
+                span.set_attribute("input.mime_type", "application/json")
+                span.set_attribute("input.value", inputs)
 
                 outputs = []
                 for item in func(*args, **kwargs):
@@ -293,7 +302,10 @@ def _opentelemetry_traced(
                     span.add_event(f"Yielded: {item}")
                     yield item
                 output = output_processor(outputs) if output_processor else outputs
-                span.set_attribute("output", json.dumps(output, default=str))
+                span.set_attribute(
+                    "output.value", _SpanUtils.format_object_for_trace_json(output)
+                )
+                span.set_attribute("output.mime_type", "application/json")
             except Exception as e:
                 span.record_exception(e)
                 span.set_status(
@@ -324,7 +336,8 @@ def _opentelemetry_traced(
                 if input_processor:
                     processed_inputs = input_processor(json.loads(inputs))
                     inputs = json.dumps(processed_inputs, default=str)
-                span.set_attribute("inputs", inputs)
+                span.set_attribute("input.mime_type", "application/json")
+                span.set_attribute("input.value", inputs)
 
                 outputs = []
                 async for item in func(*args, **kwargs):
@@ -332,7 +345,10 @@ def _opentelemetry_traced(
                     span.add_event(f"Yielded: {item}")
                     yield item
                 output = output_processor(outputs) if output_processor else outputs
-                span.set_attribute("output", json.dumps(output, default=str))
+                span.set_attribute(
+                    "output.value", _SpanUtils.format_object_for_trace_json(output)
+                )
+                span.set_attribute("output.mime_type", "application/json")
             except Exception as e:
                 span.record_exception(e)
                 span.set_status(

{uipath-2.1.57 → uipath-2.1.58}/src/uipath/tracing/_utils.py

@@ -4,10 +4,12 @@ import logging
 import os
 import random
 import uuid
-from dataclasses import dataclass, field
-from datetime import datetime
+from dataclasses import asdict, dataclass, field, is_dataclass
+from datetime import datetime, timezone
+from enum import Enum
 from os import environ as env
 from typing import Any, Dict, Optional
+from zoneinfo import ZoneInfo
 
 from opentelemetry.sdk.trace import ReadableSpan
 from opentelemetry.trace import StatusCode
@@ -15,6 +17,36 @@ from opentelemetry.trace import StatusCode
 logger = logging.getLogger(__name__)
 
 
+def _simple_serialize_defaults(obj):
+    if hasattr(obj, "model_dump"):
+        return obj.model_dump(exclude_none=True, mode="json")
+    if hasattr(obj, "dict"):
+        return obj.dict()
+    if hasattr(obj, "to_dict"):
+        return obj.to_dict()
+
+    # Handle dataclasses
+    if is_dataclass(obj) and not isinstance(obj, type):
+        return asdict(obj)
+
+    # Handle enums
+    if isinstance(obj, Enum):
+        return obj.value
+
+    if isinstance(obj, (set, tuple)):
+        if hasattr(obj, "_asdict") and callable(obj._asdict):
+            return obj._asdict()
+        return list(obj)
+
+    if isinstance(obj, datetime):
+        return obj.isoformat()
+
+    if isinstance(obj, (timezone, ZoneInfo)):
+        return obj.tzname(None)
+
+    return str(obj)
+
+
 @dataclass
 class UiPathSpan:
     """Represents a span in the UiPath tracing system."""
@@ -150,30 +182,32 @@ class _SpanUtils:
             status = 2  # Error
             attributes_dict["error"] = otel_span.status.description
 
-        original_inputs = attributes_dict.get("inputs", None)
-        original_outputs = attributes_dict.get("outputs", None)
+        original_inputs = attributes_dict.get("input", None)
+        original_outputs = attributes_dict.get("output", None)
 
         if original_inputs:
             try:
                 if isinstance(original_inputs, str):
                     json_inputs = json.loads(original_inputs)
-                    attributes_dict["inputs"] = json_inputs
+                    attributes_dict["input.value"] = json_inputs
+                    attributes_dict["input.mime_type"] = "application/json"
                 else:
-                    attributes_dict["inputs"] = original_inputs
+                    attributes_dict["input.value"] = original_inputs
             except Exception as e:
-                print(f"Error parsing inputs: {e}")
-                attributes_dict["inputs"] = str(original_inputs)
+                logger.warning(f"Error parsing inputs: {e}")
+                attributes_dict["input.value"] = str(original_inputs)
 
         if original_outputs:
             try:
                 if isinstance(original_outputs, str):
                     json_outputs = json.loads(original_outputs)
-                    attributes_dict["outputs"] = json_outputs
+                    attributes_dict["output.value"] = json_outputs
+                    attributes_dict["output.mime_type"] = "application/json"
                 else:
-                    attributes_dict["outputs"] = original_outputs
+                    attributes_dict["output.value"] = original_outputs
             except Exception as e:
-                print(f"Error parsing outputs: {e}")
-                attributes_dict["outputs"] = str(original_outputs)
+                logger.warning(f"Error parsing output: {e}")
+                attributes_dict["output.value"] = str(original_outputs)
 
         # Add events as additional attributes if they exist
         if otel_span.events:
@@ -233,7 +267,14 @@ class _SpanUtils:
     ) -> str:
         """Return a JSON string of inputs from the function signature."""
         result = _SpanUtils.format_args_for_trace(signature, *args, **kwargs)
-        return json.dumps(result, default=str)
+        return json.dumps(result, default=_simple_serialize_defaults)
+
+    @staticmethod
+    def format_object_for_trace_json(
+        input_object: Any,
+    ) -> str:
+        """Return a JSON string of inputs from the function signature."""
+        return json.dumps(input_object, default=_simple_serialize_defaults)
 
     @staticmethod
     def format_args_for_trace(

{uipath-2.1.57 → uipath-2.1.58}/tests/tracing/test_traced.py

@@ -1,6 +1,7 @@
 import json
 from asyncio import sleep
 from dataclasses import asdict, dataclass
+from enum import Enum
 from typing import Any, Dict, List, Sequence
 
 import pytest
@@ -70,9 +71,9 @@ def test_traced_sync_function(setup_tracer):
     span = spans[0]
     assert span.name == "sample_function"
     assert span.attributes["span_type"] == "function_call_sync"
-    assert "inputs" in span.attributes
-    assert "output" in span.attributes
-    assert span.attributes["output"] == "5"
+    assert "input.value" in span.attributes
+    assert "output.value" in span.attributes
+    assert span.attributes["output.value"] == "5"
 
 
 @pytest.mark.asyncio
@@ -95,9 +96,9 @@ async def test_traced_async_function(setup_tracer):
     span = spans[0]
     assert span.name == "sample_async_function"
     assert span.attributes["span_type"] == "function_call_async"
-    assert "inputs" in span.attributes
-    assert "output" in span.attributes
-    assert span.attributes["output"] == "6"
+    assert "input.value" in span.attributes
+    assert "output.value" in span.attributes
+    assert span.attributes["output.value"] == "6"
 
 
 def test_traced_generator_function(setup_tracer):
@@ -118,9 +119,9 @@ def test_traced_generator_function(setup_tracer):
     span = spans[0]
     assert span.name == "sample_generator_function"
     assert span.attributes["span_type"] == "function_call_generator_sync"
-    assert "inputs" in span.attributes
-    assert "output" in span.attributes
-    assert span.attributes["output"] == "[0, 1, 2]"
+    assert "input.value" in span.attributes
+    assert "output.value" in span.attributes
+    assert span.attributes["output.value"] == "[0, 1, 2]"
 
 
 @pytest.mark.asyncio
@@ -142,9 +143,9 @@ async def test_traced_async_generator_function(setup_tracer):
     span = spans[0]
     assert span.name == "sample_async_generator_function"
     assert span.attributes["span_type"] == "function_call_generator_async"
-    assert "inputs" in span.attributes
-    assert "output" in span.attributes
-    assert span.attributes["output"] == "[0, 1, 2]"
+    assert "input.value" in span.attributes
+    assert "output.value" in span.attributes
+    assert span.attributes["output.value"] == "[0, 1, 2]"
 
 
 def test_traced_with_basic_processors(setup_tracer):
@@ -178,13 +179,13 @@ def test_traced_with_basic_processors(setup_tracer):
     span = spans[0]
 
     # Check that input processor was applied (doubles the inputs)
-    inputs_json = span.attributes["inputs"]
+    inputs_json = span.attributes["input.value"]
     inputs = json.loads(inputs_json)
     assert inputs["x"] == 6  # 3 doubled to 6
     assert inputs["y"] == 8  # 4 doubled to 8
 
     # Check that output processor was applied (formatted as string in dict)
-    output_json = span.attributes["output"]
+    output_json = span.attributes["output.value"]
     output = json.loads(output_json)
     assert output == {"result": "12"}  # Result wrapped in dict with string conversion
 
@@ -225,13 +226,13 @@ async def test_traced_async_with_basic_processors(setup_tracer):
     span = spans[0]
 
     # Check that input processor was applied
-    inputs_json = span.attributes["inputs"]
+    inputs_json = span.attributes["input.value"]
     inputs = json.loads(inputs_json)
     assert inputs["message"] == "hello"
     assert inputs["context"] == "test"  # Added by processor
 
     # Check that output processor was applied
-    output_json = span.attributes["output"]
+    output_json = span.attributes["output.value"]
     output = json.loads(output_json)
     assert output["status"] == "completed"
     assert output["message"] == "hello"
@@ -345,7 +346,7 @@ def test_traced_with_input_processor(setup_tracer):
     assert span.name == "process_payment"
 
     # Verify inputs were processed
-    inputs_json = span.attributes["inputs"]
+    inputs_json = span.attributes["input.value"]
     inputs = json.loads(inputs_json)
     assert "card_number" in inputs
     assert inputs["card_number"] == "**** **** **** 1111"  # Should be masked
@@ -381,7 +382,7 @@ def test_traced_with_output_processor(setup_tracer):
     span = spans[0]
 
     # Verify output was processed for tracing
-    output_json = span.attributes["output"]
+    output_json = span.attributes["output.value"]
     output = json.loads(output_json)
     assert output["user_info"]["name"] == "Anonymous User"
     assert output["user_info"]["email"] == "anonymous@example.com"
@@ -412,7 +413,7 @@ def test_traced_with_dataclass_output(setup_tracer):
     spans = exporter.get_exported_spans()
 
     # Verify the output was processed for tracing
-    output_json = spans[0].attributes["output"]
+    output_json = spans[0].attributes["output.value"]
     output = json.loads(output_json)
     assert "email" in output
     assert output["email"] == "anonymous@example.com"  # Masked in the trace
@@ -450,12 +451,12 @@ async def test_traced_async_with_processors(setup_tracer):
     span = spans[0]
 
     # Verify inputs were processed
-    inputs_json = span.attributes["inputs"]
+    inputs_json = span.attributes["input.value"]
     inputs = json.loads(inputs_json)
     assert inputs["card_number"] == "**** **** **** 4444"
 
     # Verify outputs were processed
-    output_json = span.attributes["output"]
+    output_json = span.attributes["output.value"]
     output = json.loads(output_json)
     assert output["user_info"]["name"] == "Anonymous User"
     assert output["user_info"]["email"] == "anonymous@example.com"
@@ -488,12 +489,12 @@ def test_traced_generator_with_processors(setup_tracer):
     span = spans[0]
 
     # Verify inputs were processed
-    inputs_json = span.attributes["inputs"]
+    inputs_json = span.attributes["input.value"]
     inputs = json.loads(inputs_json)
     assert inputs["card_number"] == "**** **** **** 1111"
 
     # Verify outputs were processed
-    output_json = span.attributes["output"]
+    output_json = span.attributes["output.value"]
     output = json.loads(output_json)
     assert len(output) == 3
     for transaction in output:
@@ -532,12 +533,12 @@ async def test_traced_async_generator_with_processors(setup_tracer):
     span = spans[0]
 
     # Verify inputs were processed
-    inputs_json = span.attributes["inputs"]
+    inputs_json = span.attributes["input.value"]
     inputs = json.loads(inputs_json)
     assert inputs["card_number"] == "**** **** **** 4444"
 
     # Verify outputs were processed
-    output_json = span.attributes["output"]
+    output_json = span.attributes["output.value"]
     output = json.loads(output_json)
     assert len(output) == 2
     for transaction in output:
@@ -565,10 +566,87 @@ def test_traced_with_hide_input_outputs(setup_tracer):
     span = spans[0]
 
     # Verify both inputs and outputs were redacted
-    inputs_json = span.attributes["inputs"]
+    inputs_json = span.attributes["input.value"]
     inputs = json.loads(inputs_json)
     assert inputs == {"redacted": "Input data not logged for privacy/security"}
 
-    output_json = span.attributes["output"]
+    output_json = span.attributes["output.value"]
     output = json.loads(output_json)
     assert output == {"redacted": "Output data not logged for privacy/security"}
+
+
+class Operator(Enum):
+    ADD = "+"
+    SUBTRACT = "-"
+    MULTIPLY = "*"
+    DIVIDE = "/"
+
+
+@dataclass
+class CalculatorInput:
+    a: float = 0.0
+    b: float = 0.0
+    operator: Operator = Operator.ADD
+
+
+@dataclass
+class CalculatorOutput:
+    result: float = 0.0
+    operator: Operator = Operator.ADD
+
+
+def test_traced_complex_input_serialization(setup_tracer):
+    """Test that traced decorator properly serializes complex inputs like dataclasses with enums."""
+    exporter, provider = setup_tracer
+
+    @traced()
+    def test_complex_input(input: CalculatorInput) -> CalculatorOutput:
+        assert isinstance(input.a, float)
+        assert isinstance(input.b, float)
+        assert isinstance(input.operator, Operator)
+        return CalculatorOutput(result=(input.a * input.b), operator=Operator.MULTIPLY)
+
+    # Create a complex input with dataclass and enum
+    calculator_input = CalculatorInput(a=10.5, b=5.2, operator=Operator.MULTIPLY)
+    test_complex_input(calculator_input)
+
+    provider.shutdown()  # Ensure spans are flushed
+    spans = exporter.get_exported_spans()
+
+    assert len(spans) == 1
+    span = spans[0]
+    assert span.name == "test_complex_input"
+    assert span.attributes["span_type"] == "function_call_sync"
+
+    # Verify that inputs are properly serialized as JSON
+    assert "input.value" in span.attributes
+    inputs_json = span.attributes["input.value"]
+    inputs = json.loads(inputs_json)
+
+    # Debug: Print the actual inputs structure
+    print(f"Inputs JSON: {inputs_json}")
+    print(f"Parsed inputs: {inputs}")
+
+    # Check that the dataclass is properly serialized
+    assert "input" in inputs
+    input_data = inputs["input"]
+
+    # Verify the dataclass fields are properly serialized
+    assert input_data["a"] == 10.5
+    assert input_data["b"] == 5.2
+    # Verify the enum is serialized as its value
+    assert input_data["operator"] == "*"
+
+    # Verify that outputs are properly serialized as JSON
+    assert "output.value" in span.attributes
+    output_json = span.attributes["output.value"]
+    output = json.loads(output_json)
+
+    # Debug: Print the actual output structure
+    print(f"Output JSON: {output_json}")
+    print(f"Parsed output: {output}")
+
+    # Verify the output dataclass fields are properly serialized
+    assert output["result"] == 54.6  # 10.5 * 5.2 = 54.6
+    # Verify the enum is serialized as its value
+    assert output["operator"] == "*"

{uipath-2.1.57 → uipath-2.1.58}/uv.lock

@@ -2092,7 +2092,7 @@ wheels = [
 
 [[package]]
 name = "uipath"
-version = "2.1.57"
+version = "2.1.58"
 source = { editable = "." }
 dependencies = [
     { name = "azure-monitor-opentelemetry" },