uipath 2.1.54__py3-none-any.whl → 2.1.56__py3-none-any.whl

uipath/_cli/_runtime/_contracts.py

@@ -24,7 +24,7 @@ from opentelemetry.trace import Tracer
 from pydantic import BaseModel, Field
 
 from uipath.agent.conversation import UiPathConversationEvent, UiPathConversationMessage
-from uipath.tracing import LlmOpsHttpExporter, TracingManager
+from uipath.tracing import TracingManager
 
 from ._logging import LogsInterceptor
 
@@ -698,8 +698,6 @@ class UiPathRuntimeFactory(Generic[T, C]):
         self.tracer_provider: TracerProvider = TracerProvider()
         self.tracer_span_processors: List[SpanProcessor] = []
         trace.set_tracer_provider(self.tracer_provider)
-        if os.getenv("UIPATH_JOB_KEY"):
-            self.add_span_exporter(LlmOpsHttpExporter())
 
     def add_span_exporter(
         self,

uipath/_cli/cli_eval.py

@@ -14,6 +14,7 @@ from uipath._cli._runtime._contracts import (
 from uipath._cli._runtime._runtime import UiPathScriptRuntime
 from uipath._cli.middlewares import Middlewares
 from uipath.eval._helpers import auto_discover_entrypoint
+from uipath.tracing import LlmOpsHttpExporter
 
 from .._utils.constants import ENV_JOB_ID
 from ..telemetry import track
@@ -108,6 +109,8 @@ def eval(
                 UiPathRuntimeContext,
                 context_generator=generate_runtime_context,
             )
+            if not no_report or eval_context.job_id:
+                runtime_factory.add_span_exporter(LlmOpsHttpExporter())
 
             async def execute():
                 async with UiPathEvalRuntime.from_eval_context(

uipath/_cli/cli_run.py

@@ -7,6 +7,7 @@ from typing import Optional
 import click
 
 from uipath._cli._utils._debug import setup_debugging
+from uipath.tracing import LlmOpsHttpExporter
 
 from .._utils.constants import (
     ENV_JOB_ID,
@@ -102,6 +103,7 @@ def run(
             runtime_factory = UiPathRuntimeFactory(
                 UiPathScriptRuntime, UiPathRuntimeContext
             )
+
             context = UiPathRuntimeContext.with_defaults(
                 entrypoint=entrypoint,
                 input=input,
@@ -110,6 +112,8 @@ def run(
                 execution_output_file=output_file,
                 debug=debug,
             )
+            if context.job_id:
+                runtime_factory.add_span_exporter(LlmOpsHttpExporter())
 
             asyncio.run(runtime_factory.execute(context))
 

uipath/tracing/_traced.py

@@ -2,25 +2,28 @@ import importlib
 import inspect
 import json
 import logging
+from contextvars import ContextVar
 from functools import wraps
 from typing import Any, Callable, List, Optional, Tuple
 
-from opentelemetry import trace
+from opentelemetry import context, trace
+from opentelemetry.trace import set_span_in_context
 
 from ._utils import _SpanUtils
 
 logger = logging.getLogger(__name__)
 
 _tracer_instance: Optional[trace.Tracer] = None
+# ContextVar to track the currently active span for nesting
+_active_traced_span: ContextVar[Optional[trace.Span]] = ContextVar(
+    "_active_traced_span", default=None
+)
 
 
 def get_tracer() -> trace.Tracer:
     """Lazily initializes and returns the tracer instance."""
     global _tracer_instance
     if _tracer_instance is None:
-        logger.warning(
-            "Initializing tracer instance. This should only be done once per process."
-        )
         _tracer_instance = trace.get_tracer(__name__)
     return _tracer_instance
 
@@ -53,24 +56,24 @@ class TracingManager:
         """
         cls._current_span_provider = current_span_provider
 
-    @classmethod
-    def get_parent_context(cls):
-        """Get the parent context using the registered current span provider.
+    @staticmethod
+    def get_parent_context():
+        # Always use the currently active OTel span if valid (recursion / children)
+        current_span = trace.get_current_span()
+        if current_span is not None and current_span.get_span_context().is_valid:
+            return set_span_in_context(current_span)
 
-        Returns:
-            Context object with the current span set, or None if no provider is registered.
-        """
-        if cls._current_span_provider is not None:
+        # Only for the very top-level call, fallback to LangGraph span
+        if TracingManager._current_span_provider is not None:
             try:
-                current_span = cls._current_span_provider()
-                if current_span is not None:
-                    from opentelemetry.trace import set_span_in_context
-
-                    return set_span_in_context(current_span)
+                external_span = TracingManager._current_span_provider()
+                if external_span is not None:
+                    return set_span_in_context(external_span)
             except Exception as e:
                 logger.warning(f"Error getting current span from provider: {e}")
-                return None
-        return None
+
+        # Last fallback
+        return context.get_current()
 
     @classmethod
     def register_traced_function(cls, original_func, decorated_func, params):
@@ -176,176 +179,169 @@ def _opentelemetry_traced(
     """Default tracer implementation using OpenTelemetry."""
 
     def decorator(func):
-        trace_name = name if name is not None else func.__name__
+        trace_name = name or func.__name__
+
+        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:
+                return set_span_in_context(current_span)
 
+            if TracingManager._current_span_provider is not None:
+                try:
+                    external_span = TracingManager._current_span_provider()
+                    if external_span is not None:
+                        return set_span_in_context(external_span)
+                except Exception as e:
+                    logger.warning(f"Error getting current span from provider: {e}")
+
+            return context.get_current()
+
+        # --------- Sync wrapper ---------
         @wraps(func)
         def sync_wrapper(*args, **kwargs):
-            context = TracingManager.get_parent_context()
-
-            with get_tracer().start_as_current_span(
-                trace_name, context=context
-            ) as span:
-                default_span_type = "function_call_sync"
-                span.set_attribute(
-                    "span_type",
-                    span_type if span_type is not None else default_span_type,
-                )
+            ctx = get_parent_context()
+            span_cm = get_tracer().start_as_current_span(trace_name, context=ctx)
+            span = span_cm.__enter__()
+            token = _active_traced_span.set(span)
+            try:
+                span.set_attribute("span_type", span_type or "function_call_sync")
                 if run_type is not None:
                     span.set_attribute("run_type", run_type)
 
-                # Format arguments for tracing
                 inputs = _SpanUtils.format_args_for_trace_json(
                     inspect.signature(func), *args, **kwargs
                 )
-                # Apply input processor if provided
-                if input_processor is not None:
+                if input_processor:
                     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
-                    output = result
-                    if output_processor is not None:
-                        output = output_processor(result)
-                    span.set_attribute("output", json.dumps(output, default=str))
-                    return result
-                except Exception as e:
-                    span.record_exception(e)
-                    span.set_status(
-                        trace.status.Status(trace.status.StatusCode.ERROR, str(e))
-                    )
-                    raise
 
+                result = func(*args, **kwargs)
+                output = output_processor(result) if output_processor else result
+                span.set_attribute("output", json.dumps(output, default=str))
+                return result
+            except Exception as e:
+                span.record_exception(e)
+                span.set_status(
+                    trace.status.Status(trace.status.StatusCode.ERROR, str(e))
+                )
+                raise
+            finally:
+                _active_traced_span.reset(token)
+                span_cm.__exit__(None, None, None)
+
+        # --------- Async wrapper ---------
         @wraps(func)
         async def async_wrapper(*args, **kwargs):
-            context = TracingManager.get_parent_context()
-
-            with get_tracer().start_as_current_span(
-                trace_name, context=context
-            ) as span:
-                default_span_type = "function_call_async"
-                span.set_attribute(
-                    "span_type",
-                    span_type if span_type is not None else default_span_type,
-                )
+            ctx = get_parent_context()
+            span_cm = get_tracer().start_as_current_span(trace_name, context=ctx)
+            span = span_cm.__enter__()
+            token = _active_traced_span.set(span)
+            try:
+                span.set_attribute("span_type", span_type or "function_call_async")
                 if run_type is not None:
                     span.set_attribute("run_type", run_type)
 
-                # Format arguments for tracing
                 inputs = _SpanUtils.format_args_for_trace_json(
                     inspect.signature(func), *args, **kwargs
                 )
-                # Apply input processor if provided
-                if input_processor is not None:
+                if input_processor:
                     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
-                    output = result
-                    if output_processor is not None:
-                        output = output_processor(result)
-                    span.set_attribute("output", json.dumps(output, default=str))
-                    return result
-                except Exception as e:
-                    span.record_exception(e)
-                    span.set_status(
-                        trace.status.Status(trace.status.StatusCode.ERROR, str(e))
-                    )
-                    raise
 
+                result = await func(*args, **kwargs)
+                output = output_processor(result) if output_processor else result
+                span.set_attribute("output", json.dumps(output, default=str))
+                return result
+            except Exception as e:
+                span.record_exception(e)
+                span.set_status(
+                    trace.status.Status(trace.status.StatusCode.ERROR, str(e))
+                )
+                raise
+            finally:
+                _active_traced_span.reset(token)
+                span_cm.__exit__(None, None, None)
+
+        # --------- Generator wrapper ---------
         @wraps(func)
         def generator_wrapper(*args, **kwargs):
-            context = TracingManager.get_parent_context()
-
-            with get_tracer().start_as_current_span(
-                trace_name, context=context
-            ) as span:
-                span.get_span_context()
-                default_span_type = "function_call_generator_sync"
+            ctx = get_parent_context()
+            span_cm = get_tracer().start_as_current_span(trace_name, context=ctx)
+            span = span_cm.__enter__()
+            token = _active_traced_span.set(span)
+            try:
                 span.set_attribute(
-                    "span_type",
-                    span_type if span_type is not None else default_span_type,
+                    "span_type", span_type or "function_call_generator_sync"
                 )
                 if run_type is not None:
                     span.set_attribute("run_type", run_type)
 
-                # Format arguments for tracing
                 inputs = _SpanUtils.format_args_for_trace_json(
                     inspect.signature(func), *args, **kwargs
                 )
-                # Apply input processor if provided
-                if input_processor is not None:
+                if input_processor:
                     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):
-                        outputs.append(item)
-                        span.add_event(f"Yielded: {item}")  # Add event for each yield
-                        yield item
-
-                    # Process output if processor is provided
-                    output_to_record = outputs
-                    if output_processor is not None:
-                        output_to_record = output_processor(outputs)
-                    span.set_attribute(
-                        "output", json.dumps(output_to_record, default=str)
-                    )
-                except Exception as e:
-                    span.record_exception(e)
-                    span.set_status(
-                        trace.status.Status(trace.status.StatusCode.ERROR, str(e))
-                    )
-                    raise
+                for item in func(*args, **kwargs):
+                    outputs.append(item)
+                    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))
+            except Exception as e:
+                span.record_exception(e)
+                span.set_status(
+                    trace.status.Status(trace.status.StatusCode.ERROR, str(e))
+                )
+                raise
+            finally:
+                _active_traced_span.reset(token)
+                span_cm.__exit__(None, None, None)
 
+        # --------- Async generator wrapper ---------
         @wraps(func)
         async def async_generator_wrapper(*args, **kwargs):
-            context = TracingManager.get_parent_context()
-
-            with get_tracer().start_as_current_span(
-                trace_name, context=context
-            ) as span:
-                default_span_type = "function_call_generator_async"
+            ctx = get_parent_context()
+            span_cm = get_tracer().start_as_current_span(trace_name, context=ctx)
+            span = span_cm.__enter__()
+            token = _active_traced_span.set(span)
+            try:
                 span.set_attribute(
-                    "span_type",
-                    span_type if span_type is not None else default_span_type,
+                    "span_type", span_type or "function_call_generator_async"
                 )
                 if run_type is not None:
                     span.set_attribute("run_type", run_type)
 
-                # Format arguments for tracing
                 inputs = _SpanUtils.format_args_for_trace_json(
                     inspect.signature(func), *args, **kwargs
                 )
-                # Apply input processor if provided
-                if input_processor is not None:
+                if input_processor:
                     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):
-                        outputs.append(item)
-                        span.add_event(f"Yielded: {item}")  # Add event for each yield
-                        yield item
-
-                    # Process output if processor is provided
-                    output_to_record = outputs
-                    if output_processor is not None:
-                        output_to_record = output_processor(outputs)
-                    span.set_attribute(
-                        "output", json.dumps(output_to_record, default=str)
-                    )
-                except Exception as e:
-                    span.record_exception(e)
-                    span.set_status(
-                        trace.status.Status(trace.status.StatusCode.ERROR, str(e))
-                    )
-                    raise
+                async for item in func(*args, **kwargs):
+                    outputs.append(item)
+                    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))
+            except Exception as e:
+                span.record_exception(e)
+                span.set_status(
+                    trace.status.Status(trace.status.StatusCode.ERROR, str(e))
+                )
+                raise
+            finally:
+                _active_traced_span.reset(token)
+                span_cm.__exit__(None, None, None)
 
         if inspect.iscoroutinefunction(func):
             return async_wrapper

{uipath-2.1.54.dist-info → uipath-2.1.56.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: uipath
-Version: 2.1.54
+Version: 2.1.56
 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.54.dist-info → uipath-2.1.56.dist-info}/RECORD

@@ -9,7 +9,7 @@ uipath/_cli/__init__.py,sha256=tscKceSouYcEOxUbGjoyHi4qGi74giBFeXG1I-ut1hs,2308
 uipath/_cli/cli_auth.py,sha256=i3ykLlCg68xgPXHHaa0agHwGFIiLiTLzOiF6Su8XaEo,2436
 uipath/_cli/cli_deploy.py,sha256=KPCmQ0c_NYD5JofSDao5r6QYxHshVCRxlWDVnQvlp5w,645
 uipath/_cli/cli_dev.py,sha256=nEfpjw1PZ72O6jmufYWVrueVwihFxDPOeJakdvNHdOA,2146
-uipath/_cli/cli_eval.py,sha256=uiisQ3Wpalu8e9gHRMmn_9Gqus_t4brbjTegMQOhLa0,3831
+uipath/_cli/cli_eval.py,sha256=NcneGZibECVKOOdBZJ4IdWAryJM7G_JTdVSY9IORASU,4002
 uipath/_cli/cli_init.py,sha256=Ac3-9tIH3rpikIX1ehWTo7InW5tjVNoz_w6fjvgLK4w,7052
 uipath/_cli/cli_invoke.py,sha256=4jyhqcy7tPrpxvaUhW-9gut6ddsCGMdJJcpOXXmIe8g,4348
 uipath/_cli/cli_new.py,sha256=9378NYUBc9j-qKVXV7oja-jahfJhXBg8zKVyaon7ctY,2102
@@ -17,7 +17,7 @@ uipath/_cli/cli_pack.py,sha256=NmwZTfwZ2fURiHyiX1BM0juAtBOjPB1Jmcpu-rD7p-4,11025
 uipath/_cli/cli_publish.py,sha256=FmBCdeh4zFaESOLfzTTPxGcOwUtsQ_WkvF_fjHEdU8s,6448
 uipath/_cli/cli_pull.py,sha256=vwS0KMX6O2L6RaPy8tw_qzXe4dC7kf_G6nbLm0I62eI,6831
 uipath/_cli/cli_push.py,sha256=-j-gDIbT8GyU2SybLQqFl5L8KI9nu3CDijVtltDgX20,3132
-uipath/_cli/cli_run.py,sha256=7CJ3e388KCXzB5qh1eHIOL4fe7lMIxt7_1kC7iAz0A8,3559
+uipath/_cli/cli_run.py,sha256=1FKv20EjxrrP1I5rNSnL_HzbWtOAIMjB3M--4RPA_Yo,3709
 uipath/_cli/middlewares.py,sha256=GvMhDnx1BmA7rIe12s6Uqv1JdqNZhvraU0a91oqGag4,4976
 uipath/_cli/spinner.py,sha256=bS-U_HA5yne11ejUERu7CQoXmWdabUD2bm62EfEdV8M,1107
 uipath/_cli/_auth/_auth_server.py,sha256=22km0F1NFNXgyLbvtAx3ssiQlVGHroLdtDCWEqiCiMg,7106
@@ -50,7 +50,7 @@ uipath/_cli/_evals/_models/_evaluation_set.py,sha256=mwcTstHuyHd7ys_nLzgCNKBAsS4
 uipath/_cli/_evals/_models/_evaluator_base_params.py,sha256=lTYKOV66tcjW85KHTyOdtF1p1VDaBNemrMAvH8bFIFc,382
 uipath/_cli/_evals/_models/_output.py,sha256=TTQ0hhmD3dTkIbj_Ly_rDCGSnpZsHwdmCsl7FLdoZD0,2634
 uipath/_cli/_push/sw_file_handler.py,sha256=AX4TKM-q6CNGw3JyBW02M8ktPZuFMcAU9LN3Ii0Q2QI,18202
-uipath/_cli/_runtime/_contracts.py,sha256=ZK572viY3Ydnip21rzmJ3R6F3cXpHVtDTuvwcEciy3I,28782
+uipath/_cli/_runtime/_contracts.py,sha256=7JSb-2C2zWigEW5hCsVz9vz19RNR8nSaML8-PC4lkmI,28665
 uipath/_cli/_runtime/_escalation.py,sha256=x3vI98qsfRA-fL_tNkRVTFXioM5Gv2w0GFcXJJ5eQtg,7981
 uipath/_cli/_runtime/_hitl.py,sha256=VKbM021nVg1HEDnTfucSLJ0LsDn83CKyUtVzofS2qTU,11369
 uipath/_cli/_runtime/_logging.py,sha256=MGklGKPjYKjs7J5Jy9eplA9zCDsdtEbkZdCbTwgut_4,8311
@@ -144,12 +144,12 @@ uipath/telemetry/_constants.py,sha256=uRDuEZayBYtBA0tMx-2AS_D-oiVA7oKgp9zid9jNat
 uipath/telemetry/_track.py,sha256=G_Pyq8n8iMvoCWhUpWedlptXUSuUSbQBBzGxsh4DW9c,4654
 uipath/tracing/__init__.py,sha256=GKRINyWdHVrDsI-8mrZDLdf0oey6GHGlNZTOADK-kgc,224
 uipath/tracing/_otel_exporters.py,sha256=X7cnuGqvxGbACZuFD2XYTWXwIse8pokOEAjeTPE6DCQ,3158
-uipath/tracing/_traced.py,sha256=qeVDrds2OUnpdUIA0RhtF0kg2dlAZhyC1RRkI-qivTM,18528
+uipath/tracing/_traced.py,sha256=CsuNMy67R5HCunuu84LnRNwcadNLhtHLMEawGaNsTYs,18435
 uipath/tracing/_utils.py,sha256=wJRELaPu69iY0AhV432Dk5QYf_N_ViRU4kAUG1BI1ew,10384
 uipath/utils/__init__.py,sha256=VD-KXFpF_oWexFg6zyiWMkxl2HM4hYJMIUDZ1UEtGx0,105
 uipath/utils/_endpoints_manager.py,sha256=iRTl5Q0XAm_YgcnMcJOXtj-8052sr6jpWuPNz6CgT0Q,8408
-uipath-2.1.54.dist-info/METADATA,sha256=Yzw9AxJ3oi5FRDQ3ISjPi55QIWeKyNYqFSVzNnN-FXo,6482
-uipath-2.1.54.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-uipath-2.1.54.dist-info/entry_points.txt,sha256=9C2_29U6Oq1ExFu7usihR-dnfIVNSKc-0EFbh0rskB4,43
-uipath-2.1.54.dist-info/licenses/LICENSE,sha256=-KBavWXepyDjimmzH5fVAsi-6jNVpIKFc2kZs0Ri4ng,1058
-uipath-2.1.54.dist-info/RECORD,,
+uipath-2.1.56.dist-info/METADATA,sha256=FwOSIJ0R0gXGh9pIvx6xTl2GjTVElDiovjDpJ35X9ik,6482
+uipath-2.1.56.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+uipath-2.1.56.dist-info/entry_points.txt,sha256=9C2_29U6Oq1ExFu7usihR-dnfIVNSKc-0EFbh0rskB4,43
+uipath-2.1.56.dist-info/licenses/LICENSE,sha256=-KBavWXepyDjimmzH5fVAsi-6jNVpIKFc2kZs0Ri4ng,1058
+uipath-2.1.56.dist-info/RECORD,,