uipath 2.0.12__py3-none-any.whl → 2.0.14__py3-none-any.whl

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/tracing/__init__.py

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

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/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.12.dist-info → uipath-2.0.14.dist-info}/METADATA

@@ -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.dist-info → uipath-2.0.14.dist-info}/RECORD

@@ -12,7 +12,7 @@ uipath/_cli/cli_init.py,sha256=idoqlGhhzXZKmLAg-3JgZ2fYMrK7qFXYV0EhnNaI3bg,3738
 uipath/_cli/cli_new.py,sha256=SP7eWOa5valmCpc8UsOCIezL25euhglB3yJkx-N92W8,1903
 uipath/_cli/cli_pack.py,sha256=x7Je61NYzR7CR8TUoT-xeZMrXXFAsXO9PGFDUVfBU8s,12876
 uipath/_cli/cli_publish.py,sha256=_b9rehjsbxwkpH5_DtgFUaWWJqcZTg5nate-M5BnE_c,3586
-uipath/_cli/cli_run.py,sha256=dV0a-sx78T0HJHArfZP2M9YhT8d8aOuf-9OdkBqj3fE,4577
+uipath/_cli/cli_run.py,sha256=B5L7fE2IqysIEcweedU8GEy7ekMGwpeRagYBCB_cdQI,4597
 uipath/_cli/middlewares.py,sha256=IiJgjsqrJVKSXx4RcIKHWoH-SqWqpHPbhzkQEybmAos,3937
 uipath/_cli/_auth/_auth_server.py,sha256=vrzrE-hDx8exM5p2sFVoT9vKMblOyFWUvFXz-lTXceY,7077
 uipath/_cli/_auth/_models.py,sha256=sYMCfvmprIqnZxStlD_Dxx2bcxgn0Ri4D7uwemwkcNg,948
@@ -69,12 +69,12 @@ uipath/models/job.py,sha256=f9L6_kg_VP0dAYvdcz1DWEWzy4NZPdlpHREod0uNK1E,3099
 uipath/models/llm_gateway.py,sha256=0sl5Wtve94V14H3AHwmJSoXAhoc-Fai3wJxP8HrnBPg,1994
 uipath/models/processes.py,sha256=Atvfrt6X4TYST3iA62jpS_Uxc3hg6uah11p-RaKZ6dk,2029
 uipath/models/queues.py,sha256=N_s0GKucbyjh0RnO8SxPk6wlRgvq8KIIYsfaoIY46tM,6446
-uipath/tracing/__init__.py,sha256=mQEKHs47ufpy3MxphTJRh6AQsH90y6pWW80Nqbs0Q9c,157
-uipath/tracing/_otel_exporters.py,sha256=Fo10ofCWGd6PN5ndEsHkw6FZgQT5zOlob2XGnkiWvZE,2056
-uipath/tracing/_traced.py,sha256=9EUy7-OlBOApcKx4L8pwXCUJQQSl0Qh5IPvLGd27cS0,10913
+uipath/tracing/__init__.py,sha256=GimSzv6qkCOlHOG1WtjYKJsZqcXpA28IgoXfR33JhiA,139
+uipath/tracing/_otel_exporters.py,sha256=x0PDPmDKJcxashsuehVsSsqBCzRr6WsNFaq_3_HS5F0,3014
+uipath/tracing/_traced.py,sha256=9nEjFjGuxPlJ_4OXoClJ79xcbFK6C8iyI03kQQSDaJg,14834
 uipath/tracing/_utils.py,sha256=5SwsTGpHkIouXBndw-u8eCLnN4p7LM8DsTCCuf2jJgs,10165
-uipath-2.0.12.dist-info/METADATA,sha256=hzh4ODa7bKR-z6ee1CqMLOkzWGIXCAXm6TkEgI9r0JE,6078
-uipath-2.0.12.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-uipath-2.0.12.dist-info/entry_points.txt,sha256=9C2_29U6Oq1ExFu7usihR-dnfIVNSKc-0EFbh0rskB4,43
-uipath-2.0.12.dist-info/licenses/LICENSE,sha256=-KBavWXepyDjimmzH5fVAsi-6jNVpIKFc2kZs0Ri4ng,1058
-uipath-2.0.12.dist-info/RECORD,,
+uipath-2.0.14.dist-info/METADATA,sha256=IaNBRJ_zhb0K7FfqtxqwtiH5LspaDLhgEZ45H93Pv8U,6078
+uipath-2.0.14.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+uipath-2.0.14.dist-info/entry_points.txt,sha256=9C2_29U6Oq1ExFu7usihR-dnfIVNSKc-0EFbh0rskB4,43
+uipath-2.0.14.dist-info/licenses/LICENSE,sha256=-KBavWXepyDjimmzH5fVAsi-6jNVpIKFc2kZs0Ri4ng,1058
+uipath-2.0.14.dist-info/RECORD,,