arcade-core 2.3.0__py3-none-any.whl → 2.5.0rc1__py3-none-any.whl

arcade_core/executor.py

@@ -6,11 +6,9 @@ from typing import Any
 from pydantic import BaseModel, ValidationError
 
 from arcade_core.errors import (
-    RetryableToolError,
     ToolInputError,
     ToolOutputError,
     ToolRuntimeError,
-    ToolSerializationError,
 )
 from arcade_core.output import output_factory
 from arcade_core.schema import (
@@ -69,31 +67,26 @@ class ToolExecutor:
             # return the output
             return output_factory.success(data=output, logs=tool_call_logs)
 
-        except RetryableToolError as e:
-            return output_factory.fail_retry(
-                message=e.message,
-                developer_message=e.developer_message,
-                additional_prompt_content=e.additional_prompt_content,
-                retry_after_ms=e.retry_after_ms,
-            )
-
-        except ToolSerializationError as e:
-            return output_factory.fail(message=e.message, developer_message=e.developer_message)
-
-        # should catch all tool exceptions due to the try/except in the tool decorator
         except ToolRuntimeError as e:
+            e.with_context(func.__name__)
             return output_factory.fail(
                 message=e.message,
                 developer_message=e.developer_message,
-                traceback_info=e.traceback_info(),
+                stacktrace=e.stacktrace(),
+                additional_prompt_content=getattr(e, "additional_prompt_content", None),
+                retry_after_ms=getattr(e, "retry_after_ms", None),
+                kind=e.kind,
+                can_retry=e.can_retry,
+                status_code=e.status_code,
+                extra=e.extra,
             )
 
         # if we get here we're in trouble
         except Exception as e:
             return output_factory.fail(
-                message="Error in execution",
+                message=f"Error in execution of '{func.__name__}'",
                 developer_message=str(e),
-                traceback_info=traceback.format_exc(),
+                stacktrace=traceback.format_exc(),
             )
 
     @staticmethod

arcade_core/output.py

@@ -1,7 +1,8 @@
-from typing import TypeVar
+from typing import Any, TypeVar
 
 from pydantic import BaseModel
 
+from arcade_core.errors import ErrorKind
 from arcade_core.schema import ToolCallError, ToolCallLog, ToolCallOutput
 from arcade_core.utils import coerce_empty_list_to_none
 
@@ -25,14 +26,27 @@ class ToolOutputFactory:
 
         The executor guarantees that `data` is either a string, a dict, or None.
         """
-        value: str | int | float | bool | dict | list[str] | None
+        value: str | int | float | bool | dict | list | None
         if data is None:
             value = ""
         elif hasattr(data, "result"):
-            value = getattr(data, "result", "")
+            result = getattr(data, "result", "")
+            # Handle None result the same way as None data
+            if result is None:
+                value = ""
+            # If the result is a BaseModel (e.g., from TypedDict conversion), convert to dict
+            elif isinstance(result, BaseModel):
+                value = result.model_dump()
+            # If the result is a list, check if it contains BaseModel objects
+            elif isinstance(result, list):
+                value = [
+                    item.model_dump() if isinstance(item, BaseModel) else item for item in result
+                ]
+            else:
+                value = result
         elif isinstance(data, BaseModel):
             value = data.model_dump()
-        elif isinstance(data, (str, int, float, bool, list)):
+        elif isinstance(data, (str, int, float, bool, list, dict)):
             value = data
         else:
             raise ValueError(f"Unsupported data output type: {type(data)}")
@@ -48,15 +62,26 @@ class ToolOutputFactory:
         *,
         message: str,
         developer_message: str | None = None,
-        traceback_info: str | None = None,
+        stacktrace: str | None = None,
         logs: list[ToolCallLog] | None = None,
+        additional_prompt_content: str | None = None,
+        retry_after_ms: int | None = None,
+        kind: ErrorKind = ErrorKind.UNKNOWN,
+        can_retry: bool = False,
+        status_code: int | None = None,
+        extra: dict[str, Any] | None = None,
     ) -> ToolCallOutput:
         return ToolCallOutput(
             error=ToolCallError(
                 message=message,
                 developer_message=developer_message,
-                can_retry=False,
-                traceback_info=traceback_info,
+                can_retry=can_retry,
+                additional_prompt_content=additional_prompt_content,
+                retry_after_ms=retry_after_ms,
+                stacktrace=stacktrace,
+                kind=kind,
+                status_code=status_code,
+                extra=extra,
             ),
             logs=coerce_empty_list_to_none(logs),
         )
@@ -68,9 +93,17 @@ class ToolOutputFactory:
         developer_message: str | None = None,
         additional_prompt_content: str | None = None,
         retry_after_ms: int | None = None,
-        traceback_info: str | None = None,
+        stacktrace: str | None = None,
         logs: list[ToolCallLog] | None = None,
+        kind: ErrorKind = ErrorKind.TOOL_RUNTIME_RETRY,
+        status_code: int = 500,
+        extra: dict[str, Any] | None = None,
     ) -> ToolCallOutput:
+        """
+        DEPRECATED: Use ToolOutputFactory.fail instead.
+        This method will be removed in version 3.0.0
+        """
+
         return ToolCallOutput(
             error=ToolCallError(
                 message=message,
@@ -78,7 +111,10 @@ class ToolOutputFactory:
                 can_retry=True,
                 additional_prompt_content=additional_prompt_content,
                 retry_after_ms=retry_after_ms,
-                traceback_info=traceback_info,
+                stacktrace=stacktrace,
+                kind=kind,
+                status_code=status_code,
+                extra=extra,
             ),
             logs=coerce_empty_list_to_none(logs),
         )

arcade_core/parse.py

@@ -36,6 +36,18 @@ def get_function_name_if_decorated(
                 and isinstance(decorator.func, ast.Name)
                 and decorator.func.id in decorator_ids
             )
+            # Support MCPApp tools. e.g., @app.tool or @app.tool(...)
+            or (
+                isinstance(decorator, ast.Attribute)
+                and decorator.attr == "tool"
+                and isinstance(decorator.value, ast.Name)
+            )
+            or (
+                isinstance(decorator, ast.Call)
+                and isinstance(decorator.func, ast.Attribute)
+                and decorator.func.attr == "tool"
+                and isinstance(decorator.func.value, ast.Name)
+            )
         ):
             return node.name
     return None

arcade_core/schema.py

@@ -1,3 +1,21 @@
+"""
+Arcade Core Schema
+
+Defines transport-agnostic tool schemas and runtime context protocols used
+across Arcade libraries. This includes:
+
+- Tool and toolkit specifications (parameters, outputs, requirements)
+- Transport-agnostic ToolContext carrying authorization, secrets, metadata
+- Runtime ModelContext Protocol and its namespaced sub-protocols for logs,
+  progress, resources, tools, prompts, sampling, UI, and notifications
+
+Note: ToolContext does not embed runtime capabilities; those are provided by
+implementations of ModelContext (e.g., in arcade-mcp-server) that subclasses ToolContext
+to expose the namespaced APIs to tools without changing function signatures.
+"""
+
+from __future__ import annotations
+
 import os
 from dataclasses import dataclass
 from enum import Enum
@@ -5,6 +23,8 @@ from typing import Any, Literal
 
 from pydantic import BaseModel, Field
 
+from arcade_core.errors import ErrorKind
+
 # allow for custom tool name separator
 TOOL_NAME_SEPARATOR = os.getenv("ARCADE_TOOL_NAME_SEPARATOR", ".")
 
@@ -21,10 +41,10 @@ class ValueSchema(BaseModel):
     enum: list[str] | None = None
     """The list of possible values for the value, if it is a closed list."""
 
-    properties: dict[str, "ValueSchema"] | None = None
+    properties: dict[str, ValueSchema] | None = None
     """For object types (json), the schema of nested properties."""
 
-    inner_properties: dict[str, "ValueSchema"] | None = None
+    inner_properties: dict[str, ValueSchema] | None = None
     """For array types with json items, the schema of properties for each array item."""
 
     description: str | None = None
@@ -98,7 +118,7 @@ class ToolAuthRequirement(BaseModel):
     # or
     #    client.auth.authorize(provider=AuthProvider.google, scopes=["profile", "email"])
     #
-    # The Arcade SDK translates these into the appropriate provider ID (Google) and type (OAuth2).
+    # The Arcade TDK translates these into the appropriate provider ID (Google) and type (OAuth2).
     # The only time the developer will set these is if they are using a custom auth provider.
     provider_id: str | None = None
     """The provider ID configured in Arcade that acts as an alias to well-known configuration."""
@@ -198,7 +218,7 @@ class FullyQualifiedName:
             (self.toolkit_version or "").lower(),
         ))
 
-    def equals_ignoring_version(self, other: "FullyQualifiedName") -> bool:
+    def equals_ignoring_version(self, other: FullyQualifiedName) -> bool:
         """Check if two fully-qualified tool names are equal, ignoring the version."""
         return (
             self.name.lower() == other.name.lower()
@@ -206,7 +226,7 @@ class FullyQualifiedName:
         )
 
     @staticmethod
-    def from_toolkit(tool_name: str, toolkit: ToolkitDefinition) -> "FullyQualifiedName":
+    def from_toolkit(tool_name: str, toolkit: ToolkitDefinition) -> FullyQualifiedName:
         """Creates a fully-qualified tool name from a tool name and a ToolkitDefinition."""
         return FullyQualifiedName(tool_name, toolkit.name, toolkit.version)
 
@@ -296,7 +316,16 @@ class ToolMetadataItem(BaseModel):
 
 
 class ToolContext(BaseModel):
-    """The context for a tool invocation."""
+    """The context for a tool invocation.
+
+    This type is transport-agnostic and contains only authorization,
+    secret, and metadata information needed by the tool. Runtime-specific
+    capabilities (logging, resources, etc.) are provided by a separate
+    runtime context that wraps this object.
+
+    Recommendation: For new tools, annotate the parameter as
+    `arcade_mcp_server.Context` to access namespaced runtime APIs directly.
+    """
 
     authorization: ToolAuthorizationContext | None = None
     """The authorization context for the tool invocation that requires authorization."""
@@ -310,16 +339,35 @@ class ToolContext(BaseModel):
     user_id: str | None = None
     """The user ID for the tool invocation (if any)."""
 
+    model_config = {"arbitrary_types_allowed": True}
+
+    def set_secret(self, key: str, value: str) -> None:
+        """Add or update a secret to the tool context."""
+        if self.secrets is None:
+            self.secrets = []
+        # Update existing or add new
+        for secret in self.secrets:
+            if secret.key == key:
+                secret.value = value
+                return
+        self.secrets.append(ToolSecretItem(key=key, value=value))
+
     def get_auth_token_or_empty(self) -> str:
         """Retrieve the authorization token, or return an empty string if not available."""
         return self.authorization.token if self.authorization and self.authorization.token else ""
 
     def get_secret(self, key: str) -> str:
-        """Retrieve the secret for the tool invocation."""
+        """Retrieve the secret for the tool invocation.
+
+        Raises a ValueError if the secret is not found.
+        """
         return self._get_item(key, self.secrets, "secret")
 
     def get_metadata(self, key: str) -> str:
-        """Retrieve the metadata for the tool invocation."""
+        """Retrieve the metadata for the tool invocation.
+
+        Raises a ValueError if the metadata is not found.
+        """
         return self._get_item(key, self.metadata, "metadata")
 
     def _get_item(
@@ -333,21 +381,14 @@ class ToolContext(BaseModel):
                 f"{item_name.capitalize()} key passed to get_{item_name} cannot be empty."
             )
         if not items:
-            raise ValueError(f"{item_name.capitalize()}s not found in context.")
+            raise ValueError(f"{item_name.capitalize()} '{key}' not found in context.")
 
         normalized_key = key.lower()
         for item in items:
             if item.key.lower() == normalized_key:
                 return item.value
 
-        raise ValueError(f"{item_name.capitalize()} {key} not found in context.")
-
-    def set_secret(self, key: str, value: str) -> None:
-        """Set a secret for the tool invocation."""
-        if not self.secrets:
-            self.secrets = []
-        secret = ToolSecretItem(key=str(key), value=str(value))
-        self.secrets.append(secret)
+        raise ValueError(f"{item_name.capitalize()} '{key}' not found in context.")
 
 
 class ToolCallRequest(BaseModel):
@@ -390,6 +431,8 @@ class ToolCallError(BaseModel):
 
     message: str
     """The user-facing error message."""
+    kind: ErrorKind
+    """The error kind that uniquely identifies the kind of error."""
     developer_message: str | None = None
     """The developer-facing error details."""
     can_retry: bool = False
@@ -398,8 +441,27 @@ class ToolCallError(BaseModel):
     """Additional content to be included in the retry prompt."""
     retry_after_ms: int | None = None
     """The number of milliseconds (if any) to wait before retrying the tool call."""
-    traceback_info: str | None = None
-    """The traceback information for the tool call."""
+    stacktrace: str | None = None
+    """The stacktrace information for the tool call."""
+    status_code: int | None = None
+    """The HTTP status code of the error."""
+    extra: dict[str, Any] | None = None
+    """Additional information about the error."""
+
+    @property
+    def is_toolkit_error(self) -> bool:
+        """Check if this error originated from loading a toolkit."""
+        return self.kind.name.startswith("TOOLKIT_")
+
+    @property
+    def is_tool_error(self) -> bool:
+        """Check if this error originated from a tool."""
+        return self.kind.name.startswith("TOOL_")
+
+    @property
+    def is_upstream_error(self) -> bool:
+        """Check if this error originated from an upstream service."""
+        return self.kind.name.startswith("UPSTREAM_")
 
 
 class ToolCallRequiresAuthorization(BaseModel):
@@ -418,7 +480,7 @@ class ToolCallRequiresAuthorization(BaseModel):
 class ToolCallOutput(BaseModel):
     """The output of a tool invocation."""
 
-    value: str | int | float | bool | dict | list[str] | None = None
+    value: str | int | float | bool | dict | list | None = None
     """The value returned by the tool."""
     logs: list[ToolCallLog] | None = None
     """The logs that occurred during the tool invocation."""

arcade_core/toolkit.py

@@ -6,6 +6,7 @@ import types
 from collections import defaultdict
 from pathlib import Path, PurePosixPath, PureWindowsPath
 
+import toml
 from pydantic import BaseModel, ConfigDict, field_validator
 
 from arcade_core.errors import ToolkitLoadError
@@ -59,6 +60,71 @@ class Toolkit(BaseModel):
         """
         return cls.from_package(module.__name__)
 
+    @classmethod
+    def from_directory(cls, directory: Path) -> "Toolkit":
+        """
+        Load a Toolkit from a directory.
+        """
+        pyproject_path = directory / "pyproject.toml"
+        if not pyproject_path.exists():
+            raise ToolkitLoadError(f"pyproject.toml not found in {directory}")
+
+        try:
+            with open(pyproject_path) as f:
+                pyproject_data = toml.load(f)
+
+            project_data = pyproject_data.get("project", {})
+            name = project_data.get("name")
+            if not name:
+
+                def _missing_name_error() -> ToolkitLoadError:
+                    return ToolkitLoadError("name not found in pyproject.toml")
+
+                raise _missing_name_error()  # noqa: TRY301
+
+            package_name = name
+            version = project_data.get("version", "0.0.0")
+            description = project_data.get("description", "")
+            authors = project_data.get("authors", [])
+            author_names = [author.get("name", "") for author in authors]
+
+            # For homepage and repository, you might need to look under project.urls
+            urls = project_data.get("urls", {})
+            homepage = urls.get("Homepage")
+            repo = urls.get("Repository")
+
+        except Exception as e:
+            raise ToolkitLoadError(f"Failed to load metadata from {pyproject_path}: {e}")
+
+        # Determine the actual package directory (supports src/ layout and flat layout)
+        package_dir = directory
+        try:
+            src_candidate = directory / "src" / package_name
+            flat_candidate = directory / package_name
+            if src_candidate.is_dir():
+                package_dir = src_candidate
+            elif flat_candidate.is_dir():
+                package_dir = flat_candidate
+            else:
+                # Fallback to the provided directory; tools_from_directory will de-duplicate prefixes
+                package_dir = directory
+        except Exception:
+            package_dir = directory
+
+        toolkit = cls(
+            name=name,
+            package_name=package_name,
+            version=version,
+            description=description,
+            author=author_names,
+            homepage=homepage,
+            repository=repo,
+        )
+
+        toolkit.tools = cls.tools_from_directory(package_dir, package_name)
+
+        return toolkit
+
     @classmethod
     def from_package(cls, package: str) -> "Toolkit":
         """
@@ -232,9 +298,14 @@ class Toolkit(BaseModel):
         for module_path in modules:
             relative_path = module_path.relative_to(package_dir)
             cls.validate_file(module_path)
-            import_path = ".".join(relative_path.with_suffix("").parts)
-            import_path = f"{package_name}.{import_path}"
-            tools[import_path] = get_tools_from_file(str(module_path))
+            # Build import path and avoid duplicating the package prefix if it already exists
+            relative_parts = relative_path.with_suffix("").parts
+            import_path = ".".join(relative_parts)
+            if relative_parts and relative_parts[0] == package_name:
+                full_import_path = import_path
+            else:
+                full_import_path = f"{package_name}.{import_path}" if import_path else package_name
+            tools[full_import_path] = get_tools_from_file(str(module_path))
 
         if not tools:
             raise ToolkitLoadError(f"No tools found in package {package_name}")

arcade_core/utils.py

@@ -4,6 +4,7 @@ import ast
 import inspect
 import re
 from collections.abc import Callable, Iterable
+from textwrap import dedent
 from types import UnionType
 from typing import Any, Literal, TypeVar, Union, get_args, get_origin
 
@@ -75,7 +76,9 @@ def does_function_return_value(func: Callable) -> bool:
     if source is None:
         raise ValueError("Source code not found")
 
-    tree = ast.parse(source)
+    # dedent in case the function is an inner function
+    dedented_source = dedent(source)
+    tree = ast.parse(dedented_source)
 
     class ReturnVisitor(ast.NodeVisitor):
         def __init__(self) -> None:

{arcade_core-2.3.0.dist-info → arcade_core-2.5.0rc1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: arcade-core
-Version: 2.3.0
+Version: 2.5.0rc1
 Summary: Arcade Core - Core library for Arcade platform
 Author-email: Arcade <dev@arcade.dev>
 License: MIT
@@ -14,9 +14,6 @@ Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Requires-Python: >=3.10
 Requires-Dist: loguru>=0.7.0
-Requires-Dist: opentelemetry-exporter-otlp-proto-common==1.28.2
-Requires-Dist: opentelemetry-exporter-otlp-proto-http==1.28.2
-Requires-Dist: opentelemetry-instrumentation-fastapi==0.49b2
 Requires-Dist: packaging>=24.1
 Requires-Dist: pydantic>=2.7.0
 Requires-Dist: pyjwt>=2.8.0

arcade_core-2.5.0rc1.dist-info/RECORD

@@ -0,0 +1,21 @@
+arcade_core/__init__.py,sha256=1heu3AROAjpistehPzY2H-2nkj_IjQEh-vVlVOCRF1E,88
+arcade_core/annotations.py,sha256=Nst6aejLWXlpTu7GwzWETu1gQCG1XVAUR_qcFbNvyRc,198
+arcade_core/auth.py,sha256=On9sJPOxvHjKBxgKC1yqp7oijF6KYBsG6fG8KUw-9OY,5882
+arcade_core/catalog.py,sha256=QD7PLaKBW8eBaelj3_ax7s_pgKNnOYWEIsMLtqmbtjI,41819
+arcade_core/config.py,sha256=e98XQAkYySGW9T_yrJg54BB8Wuq06GPVHp7xqe2d1vU,572
+arcade_core/config_model.py,sha256=GYO37yKi7ih6EYKPpX1Kl-K1XwM2JyEJguyaJ7j9TY8,4260
+arcade_core/context.py,sha256=J2MgbVznhJC2qarHq3dTL72W4NGYOM1pjXdI_YwgkA4,3316
+arcade_core/discovery.py,sha256=PluKGhNtJ7RYjJuPDMB8LCNinQLKzlqoAtc3dwKb6IA,8397
+arcade_core/errors.py,sha256=fsi7m6TQQSsdSNHl4rBoSN_YH3ZV910gjvBFqB207f4,13326
+arcade_core/executor.py,sha256=aFRqB4OdC4b8JJN3zekx0hOWYmihWHAZqVWVlSFXzE4,4308
+arcade_core/output.py,sha256=CMY1pHlQIR27Beiz2I-Yg1aO-P-pbsEbhBZ1RdYuflc,4040
+arcade_core/parse.py,sha256=arKGKL9C6g__tRfZ4re6IM_wAqr1v3LrOzTOBEDLhDc,2366
+arcade_core/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+arcade_core/schema.py,sha256=l1eE4__sliPIMOp70YxQMlEIpiYQWlBUWEUvr9K1wxA,16927
+arcade_core/toolkit.py,sha256=UcZ151pC8zfIFzVMYxaq31H7M0f-2qprU0PkVAzfRtI,13815
+arcade_core/utils.py,sha256=RxVIzURTtZ4nAWYB3FYGngqMMPmBBxf330Ez9eEoXaw,3109
+arcade_core/version.py,sha256=CpXi3jGlx23RvRyU7iytOMZrnspdWw4yofS8lpP1AJU,18
+arcade_core/converters/openai.py,sha256=4efdgTkvdwT44VGStBhdUmzCnoP5dysceIqPVVPG-vk,7408
+arcade_core-2.5.0rc1.dist-info/METADATA,sha256=bGOwNQd_gIRNUKIe6vheQ6bJIYW51EsjvaPVUybWM6o,2373
+arcade_core-2.5.0rc1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+arcade_core-2.5.0rc1.dist-info/RECORD,,

arcade_core/telemetry.py

@@ -1,130 +0,0 @@
-import logging
-import os
-import urllib.parse
-from typing import Optional
-
-from fastapi import FastAPI
-from opentelemetry import _logs, trace
-from opentelemetry.exporter.otlp.proto.http._log_exporter import OTLPLogExporter
-from opentelemetry.exporter.otlp.proto.http.metric_exporter import OTLPMetricExporter
-from opentelemetry.exporter.otlp.proto.http.trace_exporter import OTLPSpanExporter
-from opentelemetry.instrumentation.fastapi import FastAPIInstrumentor
-from opentelemetry.metrics import Meter, get_meter_provider, set_meter_provider
-from opentelemetry.sdk._logs import LoggerProvider, LoggingHandler
-from opentelemetry.sdk._logs.export import BatchLogRecordProcessor
-from opentelemetry.sdk.metrics import MeterProvider
-from opentelemetry.sdk.metrics.export import PeriodicExportingMetricReader
-from opentelemetry.sdk.resources import SERVICE_NAME, Resource
-from opentelemetry.sdk.trace import TracerProvider
-from opentelemetry.sdk.trace.export import BatchSpanProcessor
-
-
-class ShutdownError(Exception):
-    pass
-
-
-class OTELHandler:
-    def __init__(self, enable: bool = True, log_level: int = logging.INFO):
-        self.enable = enable
-        self.log_level = log_level
-        self._tracer_provider: Optional[TracerProvider] = None
-        self._tracer_span_exporter: Optional[OTLPSpanExporter] = None
-        self._meter_provider: Optional[MeterProvider] = None
-        self._meter_reader: Optional[PeriodicExportingMetricReader] = None
-        self._otlp_metric_exporter: Optional[OTLPMetricExporter] = None
-        self._logger_provider: Optional[LoggerProvider] = None
-        self._log_processor: Optional[BatchLogRecordProcessor] = None
-        self.environment = os.environ.get("ARCADE_ENVIRONMENT", "local")
-
-    def instrument_app(self, app: FastAPI) -> None:
-        if self.enable:
-            logging.info(
-                "🔎 Initializing OpenTelemetry. Use environment variables to configure the connection"
-            )
-            self.resource = Resource(
-                attributes={SERVICE_NAME: "arcade-worker", "environment": self.environment}
-            )
-
-            self._init_tracer()
-            self._init_metrics()
-            self._init_logging(self.log_level)
-            FastAPIInstrumentor().instrument_app(app)
-
-    def _init_tracer(self) -> None:
-        self._tracer_provider = TracerProvider(resource=self.resource)
-        trace.set_tracer_provider(self._tracer_provider)
-
-        # Create an OTLP exporter
-        self._tracer_span_exporter = OTLPSpanExporter()
-
-        try:
-            self._tracer_span_exporter.export([trace.get_tracer(__name__).start_span("ping")])
-        except Exception as e:
-            raise ConnectionError(
-                f"Could not connect to OpenTelemetry Tracer endpoint. Check OpenTelemetry configuration or disable: {e}"
-            )
-
-        # Create a batch span processor and add the exporter
-        span_processor = BatchSpanProcessor(self._tracer_span_exporter)
-        self._tracer_provider.add_span_processor(span_processor)
-
-    def _init_metrics(self) -> None:
-        self._otlp_metric_exporter = OTLPMetricExporter()
-
-        self._meter_reader = PeriodicExportingMetricReader(self._otlp_metric_exporter)
-
-        self._meter_provider = MeterProvider(
-            metric_readers=[self._meter_reader], resource=self.resource
-        )
-
-        set_meter_provider(self._meter_provider)
-
-    def get_meter(self) -> Meter:
-        return get_meter_provider().get_meter(__name__)
-
-    def _init_logging(self, log_level: int) -> None:
-        otlp_log_exporter = OTLPLogExporter()
-
-        self._logger_provider = LoggerProvider(resource=self.resource)
-        _logs.set_logger_provider(self._logger_provider)
-
-        # Create a batch span processor and add the exporter
-        self._log_processor = BatchLogRecordProcessor(otlp_log_exporter)
-        self._logger_provider.add_log_record_processor(self._log_processor)
-
-        handler = LoggingHandler(level=log_level, logger_provider=self._logger_provider)
-        logging.getLogger().addHandler(handler)
-
-        # Create a filter for urllib3 connection logs related to OpenTelemetry
-        class OTELConnectionFilter(logging.Filter):
-            def filter(self, record: logging.LogRecord) -> bool:
-                # Filter out connection logs to OpenTelemetry endpoints
-                parsed_url = urllib.parse.urlparse(
-                    os.environ.get("OTEL_EXPORTER_OTLP_ENDPOINT", "")
-                )
-                domain = parsed_url.netloc.split(":")[0]
-                return not (domain and domain in str(getattr(record, "args", ())))
-
-        # Apply the filter to the urllib3 logger
-        urllib3_logger = logging.getLogger("urllib3.connectionpool")
-        urllib3_logger.addFilter(OTELConnectionFilter())
-
-    def _shutdown_tracer(self) -> None:
-        if self._tracer_span_exporter is None:
-            raise ShutdownError("Tracer provider not initialized. Failed to shutdown")
-        self._tracer_span_exporter.shutdown()
-
-    def _shutdown_metrics(self) -> None:
-        if self._otlp_metric_exporter is None:
-            raise ShutdownError("Meter provider not initialized. Failed to shutdown")
-        self._otlp_metric_exporter.shutdown()
-
-    def _shutdown_logging(self) -> None:
-        if self._logger_provider is None:
-            raise ShutdownError("Log provider not initialized. Failed to shutdown")
-        self._logger_provider.shutdown()
-
-    def shutdown(self) -> None:
-        self._shutdown_tracer()
-        self._shutdown_metrics()
-        self._shutdown_logging()