uipath 2.1.119__tar.gz → 2.1.122__tar.gz

{uipath-2.1.119 → uipath-2.1.122}/PKG-INFO

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

@@ -1,6 +1,6 @@
 [project]
 name = "uipath"
-version = "2.1.119"
+version = "2.1.122"
 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.119 → uipath-2.1.122}/src/uipath/_cli/_evals/_progress_reporter.py

@@ -210,7 +210,7 @@ class StudioWebProgressReporter:
         }
 
     @gracefully_handle_errors
-    async def create_eval_set_run(
+    async def create_eval_set_run_sw(
         self,
         eval_set_id: str,
         agent_snapshot: StudioWebAgentSnapshot,
@@ -352,13 +352,15 @@ class StudioWebProgressReporter:
             is_coded = self._is_coded_evaluator(payload.evaluators)
             self.is_coded_eval[payload.execution_id] = is_coded
 
-            eval_set_run_id = await self.create_eval_set_run(
-                eval_set_id=payload.eval_set_id,
-                agent_snapshot=self._extract_agent_snapshot(payload.entrypoint),
-                no_of_evals=payload.no_of_evals,
-                evaluators=payload.evaluators,
-                is_coded=is_coded,
-            )
+            eval_set_run_id = payload.eval_set_run_id
+            if not eval_set_run_id:
+                eval_set_run_id = await self.create_eval_set_run_sw(
+                    eval_set_id=payload.eval_set_id,
+                    agent_snapshot=self._extract_agent_snapshot(payload.entrypoint),
+                    no_of_evals=payload.no_of_evals,
+                    evaluators=payload.evaluators,
+                    is_coded=is_coded,
+                )
             self.eval_set_run_ids[payload.execution_id] = eval_set_run_id
             current_span = trace.get_current_span()
             if current_span.is_recording():

{uipath-2.1.119 → uipath-2.1.122}/src/uipath/_cli/_evals/_runtime.py

@@ -151,6 +151,7 @@ class UiPathEvalContext(UiPathRuntimeContext):
     workers: Optional[int] = 1
     eval_set: Optional[str] = None
     eval_ids: Optional[List[str]] = None
+    eval_set_run_id: Optional[str] = None
     verbose: bool = False
 
 
@@ -214,6 +215,7 @@ class UiPathEvalRuntime(UiPathBaseRuntime, Generic[T, C]):
             EvalSetRunCreatedEvent(
                 execution_id=self.execution_id,
                 entrypoint=self.context.entrypoint or "",
+                eval_set_run_id=self.context.eval_set_run_id,
                 eval_set_id=evaluation_set.id,
                 no_of_evals=len(evaluation_set.evaluations),
                 evaluators=evaluators,

{uipath-2.1.119 → uipath-2.1.122}/src/uipath/_cli/_evals/mocks/input_mocker.py

@@ -52,7 +52,7 @@ Based on the above information, provide a realistic input to the LLM agent. Your
 OUTPUT: ONLY the simulated agent input in the exact format of the INPUT_SCHEMA in valid JSON. Do not include any explanations, quotation marks, or markdown."""
 
 
-@traced(name="__mocker__")
+@traced(name="__mocker__", recording=False)
 async def generate_llm_input(
     evaluation_item: AnyEvaluationItem,
     input_schema: Dict[str, Any],

{uipath-2.1.119 → uipath-2.1.122}/src/uipath/_cli/_evals/mocks/llm_mocker.py

@@ -82,7 +82,7 @@ class LLMMocker(Mocker):
         self.evaluation_item = evaluation_item
         assert isinstance(self.evaluation_item.mocking_strategy, LLMMockingStrategy)
 
-    @traced(name="__mocker__")
+    @traced(name="__mocker__", recording=False)
     async def response(
         self, func: Callable[[T], R], params: dict[str, Any], *args: T, **kwargs
     ) -> R:

{uipath-2.1.119 → uipath-2.1.122}/src/uipath/_cli/_utils/_constants.py

@@ -45,8 +45,6 @@ PYTHON_BINARY_EXTENSIONS = {".pickle", ".pkl"}
 
 SPECIAL_EXTENSIONS = {""}  # Extensionless binary files
 
-UIPATH_PROJECT_ID = "UIPATH_PROJECT_ID"
-
 # Pre-compute the union for optimal performance
 BINARY_EXTENSIONS = (
     IMAGE_EXTENSIONS

{uipath-2.1.119 → uipath-2.1.122}/src/uipath/_cli/cli_eval.py

@@ -12,9 +12,9 @@ from uipath._cli._evals._runtime import (
     UiPathEvalContext,
 )
 from uipath._cli._runtime._runtime_factory import generate_runtime_factory
-from uipath._cli._utils._constants import UIPATH_PROJECT_ID
 from uipath._cli._utils._folders import get_personal_workspace_key_async
 from uipath._cli.middlewares import Middlewares
+from uipath._config import UiPathConfig
 from uipath._events._event_bus import EventBus
 from uipath.eval._helpers import auto_discover_entrypoint
 from uipath.tracing import LlmOpsHttpExporter
@@ -39,12 +39,13 @@ def setup_reporting_prereq(no_report: bool) -> bool:
     if no_report:
         return False
 
-    if not os.getenv(UIPATH_PROJECT_ID, False):
+    if not UiPathConfig.is_studio_project:
         console.warning(
             "UIPATH_PROJECT_ID environment variable not set. Results will no be reported to Studio Web."
         )
         return False
-    if not os.getenv("UIPATH_FOLDER_KEY"):
+
+    if not UiPathConfig.folder_key:
         folder_key = asyncio.run(get_personal_workspace_key_async())
         if folder_key:
             os.environ["UIPATH_FOLDER_KEY"] = folder_key
@@ -55,6 +56,12 @@ def setup_reporting_prereq(no_report: bool) -> bool:
 @click.argument("entrypoint", required=False)
 @click.argument("eval_set", required=False)
 @click.option("--eval-ids", cls=LiteralOption, default="[]")
+@click.option(
+    "--eval-set-run-id",
+    required=False,
+    type=str,
+    help="Custom evaluation set run ID (if not provided, a UUID will be generated)",
+)
 @click.option(
     "--no-report",
     is_flag=True,
@@ -78,6 +85,7 @@ def eval(
     entrypoint: Optional[str],
     eval_set: Optional[str],
     eval_ids: List[str],
+    eval_set_run_id: Optional[str],
     no_report: bool,
     workers: int,
     output_file: Optional[str],
@@ -88,6 +96,7 @@ def eval(
         entrypoint: Path to the agent script to evaluate (optional, will auto-discover if not specified)
         eval_set: Path to the evaluation set JSON file (optional, will auto-discover if not specified)
         eval_ids: Optional list of evaluation IDs
+        eval_set_run_id: Custom evaluation set run ID (optional, will generate UUID if not specified)
         workers: Number of parallel workers for running evaluations
         no_report: Do not report the evaluation results
     """
@@ -95,6 +104,7 @@ def eval(
         "entrypoint": entrypoint or auto_discover_entrypoint(),
         "eval_set": eval_set,
         "eval_ids": eval_ids,
+        "eval_set_run_id": eval_set_run_id,
         "workers": workers,
         "no_report": no_report,
         "output_file": output_file,
@@ -130,6 +140,7 @@ def eval(
 
         eval_context.no_report = no_report
         eval_context.workers = workers
+        eval_context.eval_set_run_id = eval_set_run_id
 
         # Load eval set to resolve the path
         eval_set_path = eval_set or EvalHelpers.auto_discover_eval_set()

{uipath-2.1.119 → uipath-2.1.122}/src/uipath/_cli/cli_init.py

@@ -10,6 +10,7 @@ from typing import Any, Dict, Optional
 
 import click
 
+from .._config import UiPathConfig
 from .._utils.constants import ENV_TELEMETRY_ENABLED
 from ..telemetry import track
 from ..telemetry._constants import _PROJECT_KEY, _TELEMETRY_CONFIG_FILE
@@ -43,9 +44,7 @@ def create_telemetry_config_file(target_directory: str) -> None:
         return
 
     os.makedirs(uipath_dir, exist_ok=True)
-    telemetry_data = {
-        _PROJECT_KEY: os.getenv("UIPATH_PROJECT_ID", None) or str(uuid.uuid4())
-    }
+    telemetry_data = {_PROJECT_KEY: UiPathConfig.project_id or str(uuid.uuid4())}
 
     with open(telemetry_file, "w") as f:
         json.dump(telemetry_data, f, indent=4)

{uipath-2.1.119 → uipath-2.1.122}/src/uipath/_cli/cli_pack.py

@@ -8,8 +8,8 @@ from string import Template
 import click
 from pydantic import TypeAdapter
 
-from uipath._cli._utils._constants import UIPATH_PROJECT_ID
 from uipath._cli.models.runtime_schema import Bindings, RuntimeSchema
+from uipath._config import UiPathConfig
 
 from ..telemetry import track
 from ..telemetry._constants import _PROJECT_KEY, _TELEMETRY_CONFIG_FILE
@@ -35,8 +35,8 @@ def get_project_id() -> str:
         Project ID string (either from telemetry file or newly generated).
     """
     # first check if this is a studio project
-    if os.getenv(UIPATH_PROJECT_ID, None):
-        return os.getenv(UIPATH_PROJECT_ID)
+    if project_id := UiPathConfig.project_id:
+        return project_id
 
     telemetry_file = os.path.join(".uipath", _TELEMETRY_CONFIG_FILE)
 

{uipath-2.1.119 → uipath-2.1.122}/src/uipath/_cli/cli_pull.py

@@ -11,14 +11,13 @@ It handles:
 
 # type: ignore
 import asyncio
-import os
 from pathlib import Path
 
 import click
 
+from .._config import UiPathConfig
 from ..telemetry import track
 from ._utils._console import ConsoleLogger
-from ._utils._constants import UIPATH_PROJECT_ID
 from ._utils._project_files import ProjectPullError, pull_project
 
 console = ConsoleLogger()
@@ -49,10 +48,9 @@ def pull(root: Path) -> None:
         $ uipath pull
         $ uipath pull /path/to/project
     """
-    project_id = os.getenv(UIPATH_PROJECT_ID)
+    project_id = UiPathConfig.project_id
     if not project_id:
         console.error("UIPATH_PROJECT_ID environment variable not found.")
-        return
 
     download_configuration = {
         "source_code": root,

{uipath-2.1.119 → uipath-2.1.122}/src/uipath/_cli/cli_push.py

@@ -1,6 +1,5 @@
 # type: ignore
 import asyncio
-import os
 from typing import Any, AsyncIterator, Optional
 from urllib.parse import urlparse
 
@@ -8,12 +7,10 @@ import click
 
 from uipath.models.exceptions import EnrichedException
 
+from .._config import UiPathConfig
 from ..telemetry import track
 from ._push.sw_file_handler import FileOperationUpdate, SwFileHandler
 from ._utils._console import ConsoleLogger
-from ._utils._constants import (
-    UIPATH_PROJECT_ID,
-)
 from ._utils._project_files import (
     ensure_config_file,
     get_project_config,
@@ -99,7 +96,7 @@ def push(root: str, nolock: bool) -> None:
     config = get_project_config(root)
     validate_config(config)
 
-    project_id = os.getenv(UIPATH_PROJECT_ID)
+    project_id = UiPathConfig.project_id
     if not project_id:
         console.error("UIPATH_PROJECT_ID environment variable not found.")
 

uipath-2.1.122/src/uipath/_config.py

@@ -0,0 +1,44 @@
+import os
+from pathlib import Path
+from typing import Optional
+
+from pydantic import BaseModel
+
+
+class Config(BaseModel):
+    base_url: str
+    secret: str
+
+
+class ConfigurationManager:
+    _instance = None
+
+    def __new__(cls):
+        if cls._instance is None:
+            cls._instance = super().__new__(cls)
+        return cls._instance
+
+    @property
+    def bindings_file_path(self) -> Path:
+        from uipath._utils.constants import UIPATH_BINDINGS_FILE
+
+        return Path(UIPATH_BINDINGS_FILE)
+
+    @property
+    def project_id(self) -> Optional[str]:
+        from uipath._utils.constants import ENV_UIPATH_PROJECT_ID
+
+        return os.getenv(ENV_UIPATH_PROJECT_ID, None)
+
+    @property
+    def folder_key(self) -> Optional[str]:
+        from uipath._utils.constants import ENV_FOLDER_KEY
+
+        return os.getenv(ENV_FOLDER_KEY, None)
+
+    @property
+    def is_studio_project(self) -> bool:
+        return self.project_id is not None
+
+
+UiPathConfig = ConfigurationManager()

{uipath-2.1.119 → uipath-2.1.122}/src/uipath/_events/_events.py

@@ -20,6 +20,7 @@ class EvalSetRunCreatedEvent(BaseModel):
     execution_id: str
     entrypoint: str
     eval_set_id: str
+    eval_set_run_id: Optional[str] = None
     no_of_evals: int
     # skip validation to avoid abstract class instantiation
     evaluators: SkipValidation[List[AnyEvaluator]]

{uipath-2.1.119 → uipath-2.1.122}/src/uipath/_resources/CLI_REFERENCE.md

@@ -100,6 +100,7 @@ uv run uipath run --resume
         entrypoint: Path to the agent script to evaluate (optional, will auto-discover if not specified)
         eval_set: Path to the evaluation set JSON file (optional, will auto-discover if not specified)
         eval_ids: Optional list of evaluation IDs
+        eval_set_run_id: Custom evaluation set run ID (optional, will generate UUID if not specified)
         workers: Number of parallel workers for running evaluations
         no_report: Do not report the evaluation results
     
@@ -115,6 +116,7 @@ uv run uipath run --resume
 
 | Option | Type | Default | Description |
 |--------|------|---------|-------------|
+| `--eval-set-run-id` | value | `Sentinel.UNSET` | Custom evaluation set run ID (if not provided, a UUID will be generated) |
 | `--no-report` | flag | false | Do not report the evaluation results |
 | `--workers` | value | `1` | Number of parallel workers for running evaluations (default: 1) |
 | `--output-file` | value | `Sentinel.UNSET` | File path where the output will be written |

{uipath-2.1.119 → uipath-2.1.122}/src/uipath/_utils/constants.py

@@ -12,6 +12,7 @@ ENV_ROBOT_KEY = "UIPATH_ROBOT_KEY"
 ENV_TENANT_ID = "UIPATH_TENANT_ID"
 ENV_ORGANIZATION_ID = "UIPATH_ORGANIZATION_ID"
 ENV_TELEMETRY_ENABLED = "UIPATH_TELEMETRY_ENABLED"
+ENV_UIPATH_PROJECT_ID = "UIPATH_PROJECT_ID"
 
 # Headers
 HEADER_FOLDER_KEY = "x-uipath-folderkey"
@@ -47,6 +48,7 @@ COMMUNITY_agents_SUFFIX = "-community-agents"
 
 # File names
 UIPATH_CONFIG_FILE = "uipath.json"
+UIPATH_BINDINGS_FILE = "bindings.json"
 
 # Evaluators
 CUSTOM_EVALUATOR_PREFIX = "file://"

{uipath-2.1.119 → uipath-2.1.122}/src/uipath/tracing/_otel_exporters.py

@@ -32,20 +32,25 @@ def _get_llm_messages(attributes: Dict[str, Any], prefix: str) -> List[Dict[str,
     """Extracts and reconstructs LLM messages from flattened attributes."""
     messages: dict[int, dict[str, Any]] = {}
     message_prefix = f"{prefix}."
+    prefix_len = len(message_prefix)
 
     for key, value in attributes.items():
         if key.startswith(message_prefix):
-            parts = key[len(message_prefix) :].split(".")
+            # Avoid repeated string slicing and splits
+            parts = key[prefix_len:].split(".")
             if len(parts) >= 2 and parts[0].isdigit():
                 index = int(parts[0])
                 if index not in messages:
                     messages[index] = {}
                 current: Any = messages[index]
 
-                for i, part in enumerate(parts[1:-1]):
+                # Traverse parts except the last one
+                parts_len = len(parts)
+                for i in range(1, parts_len - 1):
+                    part = parts[i]
                     key_part: str | int = part
                     if part.isdigit() and (
-                        i + 2 < len(parts) and parts[i + 2].isdigit()
+                        i + 2 < parts_len and parts[i + 2].isdigit()
                     ):
                         key_part = int(part)
 
@@ -60,6 +65,10 @@ def _get_llm_messages(attributes: Dict[str, Any], prefix: str) -> List[Dict[str,
 
                 current[parts[-1]] = value
 
+    # Convert dict to list, ordered by index, avoid sorted() if we can use range
+    if not messages:
+        return []
+
     # Convert dict to list, ordered by index
     return [messages[i] for i in sorted(messages.keys())]
 
@@ -112,18 +121,30 @@ class LlmOpsHttpExporter(SpanExporter):
             f"Exporting {len(spans)} spans to {self.base_url}/llmopstenant_/api/Traces/spans"
         )
 
+        # Use optimized path: keep attributes as dict for processing
+        # Only serialize at the very end
         span_list = [
             _SpanUtils.otel_span_to_uipath_span(
-                span, custom_trace_id=self.trace_id
-            ).to_dict()
+                span, custom_trace_id=self.trace_id, serialize_attributes=False
+            ).to_dict(serialize_attributes=False)
             for span in spans
         ]
+
         url = self._build_url(span_list)
 
+        # Process spans in-place if needed - work directly with dict
         if self._extra_process_spans:
-            span_list = [self._process_span_attributes(span) for span in span_list]
+            for span_data in span_list:
+                self._process_span_attributes(span_data)
 
-        logger.debug("Payload: %s", json.dumps(span_list))
+        # Serialize attributes once at the very end
+        for span_data in span_list:
+            if isinstance(span_data.get("Attributes"), dict):
+                span_data["Attributes"] = json.dumps(span_data["Attributes"])
+
+        # Only serialize for logging if debug is enabled to avoid allocation
+        if logger.isEnabledFor(logging.DEBUG):
+            logger.debug("Payload: %s", json.dumps(span_list))
 
         return self._send_with_retries(url, span_list)
 
@@ -133,7 +154,8 @@ class LlmOpsHttpExporter(SpanExporter):
 
     def _map_llm_call_attributes(self, attributes: Dict[str, Any]) -> Dict[str, Any]:
         """Maps attributes for LLM calls, handling flattened keys."""
-        result = attributes.copy()  # Keep original attributes including basic mappings
+        # Modify attributes in place to avoid copy
+        result = attributes
 
         # Token Usage
         token_keys = {
@@ -202,7 +224,8 @@ class LlmOpsHttpExporter(SpanExporter):
 
     def _map_tool_call_attributes(self, attributes: Dict[str, Any]) -> Dict[str, Any]:
         """Maps attributes for tool calls."""
-        result = attributes.copy()  # Keep original attributes
+        # Modify attributes in place to avoid copy
+        result = attributes
 
         result["type"] = "toolCall"
         result["callId"] = attributes.get("call_id") or attributes.get("id")
@@ -225,22 +248,32 @@ class LlmOpsHttpExporter(SpanExporter):
             return self.Status.ERROR
         return self.Status.SUCCESS
 
-    def _process_span_attributes(self, span_data: Dict[str, Any]) -> Dict[str, Any]:
-        """Extracts, transforms, and maps attributes for a span."""
+    def _process_span_attributes(self, span_data: Dict[str, Any]) -> None:
+        """Extracts, transforms, and maps attributes for a span in-place.
+
+        Args:
+            span_data: Span dict with Attributes as dict or JSON string
+
+        Note:
+            Modifies span_data in-place. When optimized path is used (dict),
+            modifies dict directly. When legacy path is used (str), parse → modify → serialize.
+        """
         if "Attributes" not in span_data:
-            return span_data
+            return
 
         attributes_val = span_data["Attributes"]
         if isinstance(attributes_val, str):
+            # Legacy path: parse JSON string
             try:
                 attributes: Dict[str, Any] = json.loads(attributes_val)
             except json.JSONDecodeError as e:
                 logger.warning(f"Failed to parse attributes JSON: {e}")
-                return span_data
+                return
         elif isinstance(attributes_val, dict):
+            # Optimized path: work directly with dict
             attributes = attributes_val
         else:
-            return span_data
+            return
 
         # Determine SpanType
         if "openinference.span.kind" in attributes:
@@ -258,23 +291,23 @@ class LlmOpsHttpExporter(SpanExporter):
                     attributes[new_key] = attributes[old_key]
 
         # Apply detailed mapping based on SpanType
+        # Modify attributes dict in place to avoid allocations
         span_type = span_data.get("SpanType")
         if span_type == "completion":
-            processed_attributes = self._map_llm_call_attributes(attributes)
+            self._map_llm_call_attributes(attributes)
         elif span_type == "toolCall":
-            processed_attributes = self._map_tool_call_attributes(attributes)
-        else:
-            processed_attributes = attributes.copy()
+            self._map_tool_call_attributes(attributes)
 
-        span_data["Attributes"] = json.dumps(processed_attributes)
+        # If attributes were a string (legacy path), serialize back
+        # If dict (optimized path), leave as dict - caller will serialize once at the end
+        if isinstance(attributes_val, str):
+            span_data["Attributes"] = json.dumps(attributes)
 
         # Determine status based on error information
         error = attributes.get("error") or attributes.get("exception.message")
         status = self._determine_status(error)
         span_data["Status"] = status
 
-        return span_data
-
     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"])
@@ -323,7 +356,10 @@ class JsonLinesFileExporter(SpanExporter):
     def export(self, spans: Sequence[ReadableSpan]) -> SpanExportResult:
         try:
             uipath_spans = [
-                _SpanUtils.otel_span_to_uipath_span(span).to_dict() for span in spans
+                _SpanUtils.otel_span_to_uipath_span(
+                    span, serialize_attributes=True
+                ).to_dict(serialize_attributes=True)
+                for span in spans
             ]
 
             with open(self.file_path, "a") as f:

{uipath-2.1.119 → uipath-2.1.122}/src/uipath/tracing/_traced.py

@@ -7,7 +7,7 @@ from functools import wraps
 from typing import Any, Callable, List, Optional, Tuple
 
 from opentelemetry import context, trace
-from opentelemetry.trace import set_span_in_context
+from opentelemetry.trace import NonRecordingSpan, set_span_in_context
 
 from ._utils import _SpanUtils
 
@@ -175,6 +175,7 @@ def _opentelemetry_traced(
     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."""
 
@@ -184,7 +185,10 @@ def _opentelemetry_traced(
         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:
+            if current_span is not None and (
+                current_span.get_span_context().is_valid
+                or isinstance(current_span, NonRecordingSpan)
+            ):
                 return set_span_in_context(current_span)
 
             if TracingManager._current_span_provider is not None:
@@ -197,12 +201,22 @@ def _opentelemetry_traced(
 
             return context.get_current()
 
+        def get_span():
+            if recording and not isinstance(
+                _active_traced_span.get(), NonRecordingSpan
+            ):
+                ctx = get_parent_context()
+                span_cm = get_tracer().start_as_current_span(trace_name, context=ctx)
+                span = span_cm.__enter__()
+            else:
+                span_cm = None
+                span = NonRecordingSpan(trace.INVALID_SPAN_CONTEXT)
+            return span_cm, span
+
         # --------- Sync wrapper ---------
         @wraps(func)
         def sync_wrapper(*args, **kwargs):
-            ctx = get_parent_context()
-            span_cm = get_tracer().start_as_current_span(trace_name, context=ctx)
-            span = span_cm.__enter__()
+            span_cm, span = get_span()
             token = _active_traced_span.set(span)
             try:
                 span.set_attribute("span_type", span_type or "function_call_sync")
@@ -241,14 +255,13 @@ def _opentelemetry_traced(
                 raise
             finally:
                 _active_traced_span.reset(token)
-                span_cm.__exit__(None, None, None)
+                if span_cm:
+                    span_cm.__exit__(None, None, None)
 
         # --------- Async wrapper ---------
         @wraps(func)
         async def async_wrapper(*args, **kwargs):
-            ctx = get_parent_context()
-            span_cm = get_tracer().start_as_current_span(trace_name, context=ctx)
-            span = span_cm.__enter__()
+            span_cm, span = get_span()
             token = _active_traced_span.set(span)
             try:
                 span.set_attribute("span_type", span_type or "function_call_async")
@@ -287,14 +300,13 @@ def _opentelemetry_traced(
                 raise
             finally:
                 _active_traced_span.reset(token)
-                span_cm.__exit__(None, None, None)
+                if span_cm:
+                    span_cm.__exit__(None, None, None)
 
         # --------- Generator wrapper ---------
         @wraps(func)
         def generator_wrapper(*args, **kwargs):
-            ctx = get_parent_context()
-            span_cm = get_tracer().start_as_current_span(trace_name, context=ctx)
-            span = span_cm.__enter__()
+            span_cm, span = get_span()
             token = _active_traced_span.set(span)
             try:
                 span.set_attribute(
@@ -330,14 +342,13 @@ def _opentelemetry_traced(
                 raise
             finally:
                 _active_traced_span.reset(token)
-                span_cm.__exit__(None, None, None)
+                if span_cm:
+                    span_cm.__exit__(None, None, None)
 
         # --------- Async generator wrapper ---------
         @wraps(func)
         async def async_generator_wrapper(*args, **kwargs):
-            ctx = get_parent_context()
-            span_cm = get_tracer().start_as_current_span(trace_name, context=ctx)
-            span = span_cm.__enter__()
+            span_cm, span = get_span()
             token = _active_traced_span.set(span)
             try:
                 span.set_attribute(
@@ -373,7 +384,8 @@ def _opentelemetry_traced(
                 raise
             finally:
                 _active_traced_span.reset(token)
-                span_cm.__exit__(None, None, None)
+                if span_cm:
+                    span_cm.__exit__(None, None, None)
 
         if inspect.iscoroutinefunction(func):
             return async_wrapper
@@ -425,6 +437,7 @@ def traced(
     output_processor: Optional[Callable[..., Any]] = None,
     hide_input: bool = False,
     hide_output: bool = False,
+    recording: bool = True,
 ):
     """Decorator that will trace function invocations.
 
@@ -437,6 +450,7 @@ def traced(
             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 regardless of their recording status.
     """
     # Apply default processors selectively based on hide flags
     if hide_input:
@@ -451,6 +465,7 @@ def traced(
         "span_type": span_type,
         "input_processor": input_processor,
         "output_processor": output_processor,
+        "recording": recording,
     }
 
     # Check for custom implementation first