uipath-core 0.0.2__py3-none-any.whl

uipath/core/__init__.py

@@ -0,0 +1,9 @@
+"""UiPath Core Package."""
+
+from uipath.core.tracing.decorators import traced
+from uipath.core.tracing.manager import UiPathTracingManager
+
+__all__ = [
+    "traced",
+    "UiPathTracingManager",
+]

uipath/core/tracing/__init__.py

@@ -0,0 +1,15 @@
+"""OpenTelemetry tracing module with UiPath integration.
+
+This module provides decorators and utilities for instrumenting Python functions
+with OpenTelemetry tracing, including custom processors for UiPath execution tracking.
+"""
+
+from uipath.core.tracing.context import UiPathTraceContext
+from uipath.core.tracing.decorators import traced
+from uipath.core.tracing.manager import UiPathTracingManager
+
+__all__ = [
+    "traced",
+    "UiPathTraceContext",
+    "UiPathTracingManager",
+]

uipath/core/tracing/_utils.py

@@ -0,0 +1,122 @@
+"""Helper utilities for the tracing module."""
+
+import inspect
+import json
+from collections.abc import Callable
+from dataclasses import asdict, is_dataclass
+from datetime import datetime, timezone
+from enum import Enum
+from typing import Any, Dict, Mapping
+from zoneinfo import ZoneInfo
+
+from pydantic import BaseModel
+
+
+def get_supported_params(
+    tracer_impl: Callable[..., Any],
+    params: Mapping[str, Any],
+) -> Dict[str, Any]:
+    """Extract the parameters supported by the tracer implementation."""
+    try:
+        sig = inspect.signature(tracer_impl)
+    except (TypeError, ValueError):
+        # If we can't inspect, pass all parameters and let the function handle it
+        return dict(params)
+
+    supported: Dict[str, Any] = {}
+    for name, value in params.items():
+        if value is not None and name in sig.parameters:
+            supported[name] = value
+    return supported
+
+
+def _simple_serialize_defaults(obj):
+    # Handle Pydantic BaseModel instances
+    if hasattr(obj, "model_dump") and not isinstance(obj, type):
+        return obj.model_dump(exclude_none=True, mode="json")
+
+    # Handle classes - convert to schema representation
+    if isinstance(obj, type) and issubclass(obj, BaseModel):
+        return {
+            "__class__": obj.__name__,
+            "__module__": obj.__module__,
+            "schema": obj.model_json_schema(),
+        }
+    if hasattr(obj, "dict") and not isinstance(obj, type):
+        return obj.dict()
+    if hasattr(obj, "to_dict") and not isinstance(obj, type):
+        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 _simple_serialize_defaults(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)
+
+    # Allow JSON-serializable primitives to pass through unchanged
+    if obj is None or isinstance(obj, (bool, int, float, str)):
+        return obj
+
+    return str(obj)
+
+
+def format_args_for_trace_json(
+    signature: inspect.Signature, *args: Any, **kwargs: Any
+) -> str:
+    """Return a JSON string of inputs from the function signature."""
+    result = format_args_for_trace(signature, *args, **kwargs)
+    return json.dumps(result, default=_simple_serialize_defaults)
+
+
+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)
+
+
+def format_args_for_trace(
+    signature: inspect.Signature, *args: Any, **kwargs: Any
+) -> Dict[str, Any]:
+    try:
+        """Return a dictionary of inputs from the function signature."""
+        # Create a parameter mapping by partially binding the arguments
+
+        parameter_binding = signature.bind_partial(*args, **kwargs)
+
+        # Fill in default values for any unspecified parameters
+        parameter_binding.apply_defaults()
+
+        # Extract the input parameters, skipping special Python parameters
+        result = {}
+        for name, value in parameter_binding.arguments.items():
+            # Skip class and instance references
+            if name in ("self", "cls"):
+                continue
+
+            # Handle **kwargs parameters specially
+            param_info = signature.parameters.get(name)
+            if param_info and param_info.kind == inspect.Parameter.VAR_KEYWORD:
+                # Flatten nested kwargs directly into the result
+                if isinstance(value, dict):
+                    result.update(value)
+            else:
+                # Regular parameter
+                result[name] = value
+
+        return result
+    except Exception:
+        return {"args": args, "kwargs": kwargs}

uipath/core/tracing/context.py

@@ -0,0 +1,23 @@
+"""Trace context information for tracing and debugging."""
+
+from typing import Optional, Union
+
+from pydantic import BaseModel
+
+
+class UiPathTraceContext(BaseModel):
+    """Trace context information for tracing and debugging."""
+
+    trace_id: Optional[str] = None
+    parent_span_id: Optional[str] = None
+    root_span_id: Optional[str] = None
+    org_id: Optional[str] = None
+    tenant_id: Optional[str] = None
+    job_id: Optional[str] = None
+    folder_key: Optional[str] = None
+    process_key: Optional[str] = None
+    enabled: Union[bool, str] = False
+    reference_id: Optional[str] = None
+
+
+__all__ = ["UiPathTraceContext"]

uipath/core/tracing/decorators.py

@@ -0,0 +1,282 @@
+"""Tracing decorators for function instrumentation."""
+
+import inspect
+import json
+import logging
+import random
+from functools import wraps
+from typing import Any, Callable, Optional
+
+from opentelemetry import trace
+from opentelemetry.trace import NonRecordingSpan, SpanContext, TraceFlags
+from opentelemetry.trace.status import StatusCode
+
+from uipath.core.tracing._utils import (
+    format_args_for_trace_json,
+    format_object_for_trace_json,
+    get_supported_params,
+)
+from uipath.core.tracing.manager import UiPathTracingManager
+
+logger = logging.getLogger(__name__)
+
+
+def _opentelemetry_traced(
+    name: Optional[str] = None,
+    run_type: Optional[str] = None,
+    span_type: Optional[str] = None,
+    input_processor: Optional[Callable[..., Any]] = None,
+    output_processor: Optional[Callable[..., Any]] = None,
+    recording: bool = True,
+):
+    """Default tracer implementation using OpenTelemetry."""
+
+    def decorator(func):
+        trace_name = name or func.__name__
+
+        def get_span():
+            if not recording:
+                # Create a valid but non-sampled trace context
+                # Generate a valid trace ID (not INVALID)
+                trace_id = random.getrandbits(128)
+                span_id = random.getrandbits(64)
+
+                non_sampled_context = SpanContext(
+                    trace_id=trace_id,
+                    span_id=span_id,
+                    is_remote=False,
+                    trace_flags=TraceFlags(0x00),  # NOT sampled
+                )
+                non_recording = NonRecordingSpan(non_sampled_context)
+
+                # Make it active so children see it
+                span_cm = trace.use_span(non_recording)
+                span_cm.__enter__()
+                return span_cm, non_recording
+
+            # Normal recording span
+            ctx = UiPathTracingManager.get_parent_context()
+            span_cm = trace.get_tracer(__name__).start_as_current_span(
+                trace_name, context=ctx
+            )
+            span = span_cm.__enter__()
+            return span_cm, span
+
+        # --------- Sync wrapper ---------
+        @wraps(func)
+        def sync_wrapper(*args, **kwargs):
+            span_cm, span = get_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)
+
+                inputs = format_args_for_trace_json(
+                    inspect.signature(func), *args, **kwargs
+                )
+                if input_processor:
+                    processed_inputs = input_processor(json.loads(inputs))
+                    inputs = json.dumps(processed_inputs, default=str)
+
+                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.value", format_object_for_trace_json(output))
+                span.set_attribute("output.mime_type", "application/json")
+                return result
+            except Exception as e:
+                span.record_exception(e)
+                span.set_status(StatusCode.ERROR, str(e))
+                raise
+            finally:
+                if span_cm:
+                    span_cm.__exit__(None, None, None)
+
+        # --------- Async wrapper ---------
+        @wraps(func)
+        async def async_wrapper(*args, **kwargs):
+            span_cm, span = get_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)
+
+                inputs = format_args_for_trace_json(
+                    inspect.signature(func), *args, **kwargs
+                )
+                if input_processor:
+                    processed_inputs = input_processor(json.loads(inputs))
+                    inputs = json.dumps(processed_inputs, default=str)
+
+                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.value", format_object_for_trace_json(output))
+                span.set_attribute("output.mime_type", "application/json")
+                return result
+            except Exception as e:
+                span.record_exception(e)
+                span.set_status(StatusCode.ERROR, str(e))
+                raise
+            finally:
+                if span_cm:
+                    span_cm.__exit__(None, None, None)
+
+        # --------- Generator wrapper ---------
+        @wraps(func)
+        def generator_wrapper(*args, **kwargs):
+            span_cm, span = get_span()
+            try:
+                span.set_attribute(
+                    "span_type", span_type or "function_call_generator_sync"
+                )
+                if run_type is not None:
+                    span.set_attribute("run_type", run_type)
+
+                inputs = format_args_for_trace_json(
+                    inspect.signature(func), *args, **kwargs
+                )
+                if input_processor:
+                    processed_inputs = input_processor(json.loads(inputs))
+                    inputs = json.dumps(processed_inputs, default=str)
+
+                span.set_attribute("input.mime_type", "application/json")
+                span.set_attribute("input.value", inputs)
+
+                outputs = []
+                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.value", 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(StatusCode.ERROR, str(e))
+                raise
+            finally:
+                if span_cm:
+                    span_cm.__exit__(None, None, None)
+
+        # --------- Async generator wrapper ---------
+        @wraps(func)
+        async def async_generator_wrapper(*args, **kwargs):
+            span_cm, span = get_span()
+            try:
+                span.set_attribute(
+                    "span_type", span_type or "function_call_generator_async"
+                )
+                if run_type is not None:
+                    span.set_attribute("run_type", run_type)
+
+                inputs = format_args_for_trace_json(
+                    inspect.signature(func), *args, **kwargs
+                )
+                if input_processor:
+                    processed_inputs = input_processor(json.loads(inputs))
+                    inputs = json.dumps(processed_inputs, default=str)
+
+                span.set_attribute("input.mime_type", "application/json")
+                span.set_attribute("input.value", inputs)
+
+                outputs = []
+                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.value", 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(StatusCode.ERROR, str(e))
+                raise
+            finally:
+                if span_cm:
+                    span_cm.__exit__(None, None, None)
+
+        if inspect.iscoroutinefunction(func):
+            return async_wrapper
+        elif inspect.isgeneratorfunction(func):
+            return generator_wrapper
+        elif inspect.isasyncgenfunction(func):
+            return async_generator_wrapper
+        else:
+            return sync_wrapper
+
+    return decorator
+
+
+def traced(
+    name: Optional[str] = None,
+    run_type: Optional[str] = None,
+    span_type: Optional[str] = None,
+    input_processor: Optional[Callable[..., Any]] = None,
+    output_processor: Optional[Callable[..., Any]] = None,
+    hide_input: bool = False,
+    hide_output: bool = False,
+    recording: bool = True,
+):
+    """Decorator that will trace function invocations.
+
+    Args:
+        name: Optional custom name for the span
+        run_type: Optional string to categorize the run type
+        span_type: Optional string to categorize the span type
+        input_processor: Optional function to process function inputs before recording
+            Should accept a dictionary of inputs and return a processed dictionary
+        output_processor: Optional function to process function outputs before recording
+            Should accept the function output and return a processed value
+        hide_input: If True, don't log any input data
+        hide_output: If True, don't log any output data
+        recording: If False, current span and all child spans are not captured
+    """
+
+    # Apply default processors selectively based on hide flags
+    def _default_input_processor(inputs):
+        """Default input processor that doesn't log any actual input data."""
+        return {"redacted": "Input data not logged for privacy/security"}
+
+    def _default_output_processor(outputs):
+        """Default output processor that doesn't log any actual output data."""
+        return {"redacted": "Output data not logged for privacy/security"}
+
+    if hide_input:
+        input_processor = _default_input_processor
+    if hide_output:
+        output_processor = _default_output_processor
+
+    # Store the parameters for later reapplication
+    params = {
+        "name": name,
+        "run_type": run_type,
+        "span_type": span_type,
+        "input_processor": input_processor,
+        "output_processor": output_processor,
+        "recording": recording,
+    }
+
+    tracer_impl = _opentelemetry_traced
+
+    def decorator(func):
+        # Check which parameters are supported by the tracer_impl
+        supported_params = get_supported_params(tracer_impl, params)
+
+        # Decorate the function with only supported parameters
+        decorated_func = tracer_impl(**supported_params)(func)
+
+        return decorated_func
+
+    return decorator
+
+
+__all__ = ["traced"]

uipath/core/tracing/manager.py

@@ -0,0 +1,314 @@
+"""Tracing manager for handling tracer implementations and function registry."""
+
+import logging
+from typing import Callable, Dict, List, Optional
+
+from opentelemetry import context, trace
+from opentelemetry.trace import Span, set_span_in_context
+
+logger = logging.getLogger(__name__)
+
+
+class SpanRegistry:
+    """Registry to track all spans and their parent relationships."""
+
+    MAX_HIERARCHY_DEPTH = 1000  # Hard limit for hierarchy traversal
+
+    def __init__(self):
+        self._spans: Dict[int, Span] = {}  # span_id -> span
+        self._parent_map: Dict[int, Optional[int]] = {}  # span_id -> parent_id
+
+    def register_span(self, span: Span) -> None:
+        """Register a span and its parent relationship."""
+        span_id = span.get_span_context().span_id
+
+        parent_id: Optional[int] = None
+
+        if hasattr(span, "parent") and span.parent is not None:
+            parent_id = getattr(span.parent, "span_id", None)
+
+        self._spans[span_id] = span
+        self._parent_map[span_id] = parent_id
+
+        parent_str = "{:016x}".format(parent_id) if parent_id is not None else "None"
+
+        logger.debug(
+            "SpanRegistry: registered span: %s (id: %016x, parent: %s)",
+            getattr(span, "name", "unknown"),
+            span_id,
+            parent_str,
+        )
+
+    def get_span(self, span_id: int) -> Optional[Span]:
+        """Get a span by ID."""
+        return self._spans.get(span_id)
+
+    def get_parent_id(self, span_id: int) -> Optional[int]:
+        """Get the parent ID of a span."""
+        return self._parent_map.get(span_id)
+
+    def calculate_depth(self, span_id: int) -> int:
+        """Calculate the depth of a span in the hierarchy.
+
+        Returns:
+            The depth of the span, capped at MAX_HIERARCHY_DEPTH.
+        """
+        depth = 0
+        current_id = span_id
+        visited = set()
+
+        while current_id is not None and current_id not in visited:
+            visited.add(current_id)
+            parent_id = self._parent_map.get(current_id)
+            if parent_id is None:
+                break
+            depth += 1
+            if depth >= self.MAX_HIERARCHY_DEPTH:
+                logger.warning(
+                    "Hit MAX_HIERARCHY_DEPTH (%d) while calculating depth for span %016x",
+                    self.MAX_HIERARCHY_DEPTH,
+                    span_id,
+                )
+                break
+            current_id = parent_id
+
+        return depth
+
+    def is_ancestor(self, ancestor_id: int, descendant_id: int) -> bool:
+        """Check if ancestor_id is an ancestor of descendant_id.
+
+        Returns:
+            True if ancestor_id is an ancestor of descendant_id, False otherwise.
+            If MAX_HIERARCHY_DEPTH is reached, returns False.
+        """
+        current_id: Optional[int] = descendant_id
+        visited = set()
+        steps = 0
+
+        while current_id is not None and current_id not in visited:
+            if current_id == ancestor_id:
+                return True
+            visited.add(current_id)
+            current_id = self._parent_map.get(current_id)
+            steps += 1
+            if steps >= self.MAX_HIERARCHY_DEPTH:
+                logger.warning(
+                    "Hit MAX_HIERARCHY_DEPTH (%d) while checking ancestry between %016x and %016x",
+                    self.MAX_HIERARCHY_DEPTH,
+                    ancestor_id,
+                    descendant_id,
+                )
+                return False
+
+        return False
+
+    def clear(self) -> None:
+        """Clear all registered spans."""
+        self._spans.clear()
+        self._parent_map.clear()
+
+
+# Global span registry instance
+_span_registry = SpanRegistry()
+
+
+class UiPathTracingManager:
+    """Static utility class to manage tracing implementations and decorated functions."""
+
+    _current_span_provider: Optional[Callable[[], Optional[Span]]] = None
+    _current_span_ancestors_provider: Optional[Callable[[], List[Span]]] = None
+
+    @staticmethod
+    def register_current_span_provider(
+        current_span_provider: Optional[Callable[[], Optional[Span]]],
+    ):
+        """Register a custom current span provider function.
+
+        Args:
+            current_span_provider: A function that returns the current span from an external
+                                 tracing framework. If None, no custom span parenting will be used.
+        """
+        UiPathTracingManager._current_span_provider = current_span_provider
+
+    @staticmethod
+    def get_parent_context() -> context.Context:
+        """Get the parent context for span creation.
+
+        This method determines the correct parent context when creating a new traced span.
+        It handles scenarios where spans may exist in both OpenTelemetry's context (current_span)
+        and in an external tracing system (external_span), such as LangGraph.
+
+        The algorithm follows this priority:
+
+        1. **No spans available**: Returns the current OpenTelemetry context (empty context)
+
+        2. **Only current_span exists**: Returns a context with current_span set as parent
+           - This is the standard OpenTelemetry behavior for nested traced functions
+
+        3. **Only external_span exists**: Returns a context with external_span set as parent
+           - This occurs when an external tracing system (like LangGraph) has an active span
+             but there's no OTel span in the current call stack
+
+        4. **Both spans exist**: Calls `_get_bottom_most_span()` to determine which is deeper
+           - Uses the SpanRegistry to build parent-child relationships
+           - Returns the span that is closer to the "bottom" (leaf) of the trace tree
+           - This ensures new spans are always attached to the deepest/most specific parent
+
+        Context Sources:
+        - **current_span**: Retrieved from OpenTelemetry's `trace.get_current_span()`
+          - Represents the active OTel span in the current execution context
+          - Created by `@traced` decorators or manual span creation
+
+        - **external_span**: Retrieved from the registered custom span provider
+          - Set via `register_current_span_provider()`
+          - Typically provided by external frameworks (LangGraph, LangChain, etc.)
+          - Allows integration with tracing systems outside of OpenTelemetry
+
+        Returns:
+            context.Context: An OpenTelemetry context containing the appropriate parent span,
+                           or the current empty context if no spans are available
+
+        Example:
+            ```python
+            # Called by the @traced decorator when creating a new span:
+            ctx = UiPathTracingManager.get_parent_context()
+            with tracer.start_as_current_span("my_span", context=ctx) as span:
+                # New span will have the correct parent based on the logic above
+                pass
+            ```
+
+        See Also:
+            - `_get_bottom_most_span()`: Logic for choosing between two available spans
+            - `register_current_span_provider()`: Register external span provider
+            - `get_external_current_span()`: Retrieve span from external provider
+        """
+        current_span = trace.get_current_span()
+        has_current_span = (
+            current_span is not None and current_span.get_span_context().is_valid
+        )
+
+        external_span = UiPathTracingManager.get_external_current_span()
+
+        # Only one or no spans available
+        if not has_current_span:
+            return (
+                set_span_in_context(external_span)
+                if external_span is not None
+                else context.get_current()
+            )
+        if external_span is None:
+            return set_span_in_context(current_span)
+
+        # Both spans exist - find the bottom-most one
+        bottom_span = UiPathTracingManager._get_bottom_most_span(
+            current_span, external_span
+        )
+        return set_span_in_context(bottom_span)
+
+    @staticmethod
+    def _get_bottom_most_span(
+        current_span: Span,
+        external_span: Span,
+    ) -> Span:
+        """Determine which span is deeper in the ancestor tree.
+
+        Args:
+            current_span: The OTel current span
+            external_span: The external span from the provider
+
+        Returns:
+            The span that is deeper (closer to the bottom) in the call hierarchy
+        """
+        # Register both spans in the registry
+        _span_registry.register_span(current_span)
+        _span_registry.register_span(external_span)
+
+        # Also register external ancestors
+        external_ancestors = UiPathTracingManager.get_ancestor_spans() or []
+        for ancestor in external_ancestors:
+            _span_registry.register_span(ancestor)
+
+        current_span_id = current_span.get_span_context().span_id
+        external_span_id = external_span.get_span_context().span_id
+
+        # Check if one span is an ancestor of the other
+        if _span_registry.is_ancestor(external_span_id, current_span_id):
+            logger.debug(
+                "Traced Context: current_span is a descendant of external_span -> returning current_span (deeper)"
+            )
+            return current_span
+        elif _span_registry.is_ancestor(current_span_id, external_span_id):
+            logger.debug(
+                "Traced Context: external_span is a descendant of current_span -> returning external_span (deeper)"
+            )
+            return external_span
+
+        # Neither is an ancestor of the other - they're in different branches
+        # Use depth as tiebreaker
+        current_depth = _span_registry.calculate_depth(current_span_id)
+        external_depth = _span_registry.calculate_depth(external_span_id)
+
+        if current_depth > external_depth:
+            logger.debug(
+                "Traced Context: Different branches, current_span is deeper (depth %d > %d) -> returning current_span",
+                current_depth,
+                external_depth,
+            )
+            return current_span
+        elif external_depth > current_depth:
+            logger.debug(
+                "Traced Context: Different branches, external_span is deeper (depth %d > %d) -> returning external_span",
+                external_depth,
+                current_depth,
+            )
+            return external_span
+        else:
+            # Same depth, different branches - default to external
+            logger.debug(
+                "Traced Context: Same depth (%d), different branches -> defaulting to external_span",
+                current_depth,
+            )
+            return external_span
+
+    @staticmethod
+    def get_external_current_span() -> Optional[Span]:
+        """Get the current span from the external provider, if any."""
+        if UiPathTracingManager._current_span_provider is not None:
+            try:
+                return UiPathTracingManager._current_span_provider()
+            except Exception as e:
+                logger.warning("Error getting current span from provider: %s", e)
+        return None
+
+    @staticmethod
+    def get_ancestor_spans() -> List[Span]:
+        """Get the ancestor spans from the registered provider, if any."""
+        if UiPathTracingManager._current_span_ancestors_provider is not None:
+            try:
+                return UiPathTracingManager._current_span_ancestors_provider()
+            except Exception as e:
+                logger.warning("Error getting ancestor spans from provider: %s", e)
+        return []
+
+    @staticmethod
+    def register_current_span_ancestors_provider(
+        current_span_ancestors_provider: Optional[Callable[[], List[Span]]],
+    ):
+        """Register a custom current span ancestors provider function.
+
+        Args:
+            current_span_ancestors_provider: A function that returns a list of ancestor spans
+                                           from an external tracing framework. If None, no custom
+                                           span ancestor information will be used.
+        """
+        UiPathTracingManager._current_span_ancestors_provider = (
+            current_span_ancestors_provider
+        )
+
+    @staticmethod
+    def get_current_span_ancestors_provider():
+        """Get the currently set custom span ancestors provider."""
+        return UiPathTracingManager._current_span_ancestors_provider
+
+
+__all__ = ["UiPathTracingManager"]

uipath_core-0.0.2.dist-info/METADATA

@@ -0,0 +1,24 @@
+Metadata-Version: 2.4
+Name: uipath-core
+Version: 0.0.2
+Summary: UiPath Core abstractions
+Project-URL: Homepage, https://uipath.com
+Project-URL: Repository, https://github.com/UiPath/uipath-runtime-python
+Project-URL: Documentation, https://uipath.github.io/uipath-python/
+Maintainer-email: Marius Cosareanu <marius.cosareanu@uipath.com>, Cristian Pufu <cristian.pufu@uipath.com>
+License-File: LICENSE
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Build Tools
+Requires-Python: >=3.11
+Requires-Dist: opentelemetry-instrumentation>=0.59b0
+Requires-Dist: opentelemetry-sdk>=1.38.0
+Requires-Dist: pydantic>=2.12.3
+Description-Content-Type: text/markdown
+
+# UiPath Core
+
+Core abstractions and contracts for the UiPath Python SDK.

uipath_core-0.0.2.dist-info/RECORD

@@ -0,0 +1,11 @@
+uipath/core/__init__.py,sha256=Gvk2xmI4JTOOHhQYtb0jJhSK2xmlrMUVTj7BL9lZQ88,196
+uipath/core/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+uipath/core/tracing/__init__.py,sha256=bY1t3KHAkyPZ1lYFigDFIvUdw4WCNEaackA0NyZr4IM,484
+uipath/core/tracing/_utils.py,sha256=HNI07gEGjdxbSkfO9654JXszsIlN-iGRrSKdxfbQfAw,3994
+uipath/core/tracing/context.py,sha256=jLUNGIRAydtXoi0W5Fs51SHEHSPHLkixXiupzz7zN88,634
+uipath/core/tracing/decorators.py,sha256=bot1vlGcsaMre63TXLWCTrlnNitb9XE8Ynxz0w0z0mk,10721
+uipath/core/tracing/manager.py,sha256=izxopU8Ar3VQCvBmaW_SD2d1VhUjLjID9YhVDT4Qbis,12367
+uipath_core-0.0.2.dist-info/METADATA,sha256=B39O-uWDPumdj0uAiR_BLltGcshkJWu8jp6QQ-lOIlg,971
+uipath_core-0.0.2.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+uipath_core-0.0.2.dist-info/licenses/LICENSE,sha256=-KBavWXepyDjimmzH5fVAsi-6jNVpIKFc2kZs0Ri4ng,1058
+uipath_core-0.0.2.dist-info/RECORD,,

uipath_core-0.0.2.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.27.0
+Root-Is-Purelib: true
+Tag: py3-none-any

uipath_core-0.0.2.dist-info/licenses/LICENSE

@@ -0,0 +1,9 @@
+MIT License
+
+Copyright 2025 UiPath
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.