veris-ai 1.5.0__py3-none-any.whl → 1.7.0__py3-none-any.whl

veris_ai/README.md

@@ -15,7 +15,6 @@ This module contains the core implementation of the Veris AI Python SDK. Each co
 | Module | Purpose | Key Classes/Functions | Lines |
 |--------|---------|----------------------|-------|
 | [`tool_mock.py`](tool_mock.py) | Function mocking & FastAPI MCP | `VerisSDK`, `@mock`, `@stub` | 327 |
-| [`braintrust_tracing.py`](braintrust_tracing.py) | Dual tracing instrumentation | `instrument()` | 283 |
 | [`utils.py`](utils.py) | Type utilities & JSON schema | `extract_json_schema()` | 272 |
 | [`logging.py`](logging.py) | Logging configuration | `setup_logging()` | 116 |
 | [`models.py`](models.py) | Data models | Type definitions | 12 |
@@ -40,12 +39,6 @@ This module contains the core implementation of the Veris AI Python SDK. Each co
 
 **Implementation**: [`tool_mock.py:250-300`](tool_mock.py)
 
-### Tracing Flow
-1. **Dual Setup**: Braintrust + OpenTelemetry instrumentation  
-2. **Session Tagging**: Bearer tokens → session IDs
-3. **Span Attribution**: All operations tagged with `veris.session_id`
-
-**Implementation**: [`braintrust_tracing.py:50-150`](braintrust_tracing.py)
 
 ## Configuration
 

veris_ai/__init__.py

@@ -1,37 +1,17 @@
 """Veris AI Python SDK."""
 
-from typing import Any
-
 __version__ = "0.1.0"
 
 # Import lightweight modules that only use base dependencies
 from .jaeger_interface import JaegerClient
 from .models import ResponseExpectation
 from .tool_mock import veris
-
-# Lazy import for modules with heavy dependencies
-_instrument = None
-
-
-def instrument(*args: Any, **kwargs: Any) -> Any:  # noqa: ANN401
-    """Lazy loader for the instrument function from braintrust_tracing.
-
-    This function requires the 'instrument' extra dependencies:
-    pip install veris-ai[instrument]
-    """
-    global _instrument  # noqa: PLW0603
-    if _instrument is None:
-        try:
-            from .braintrust_tracing import instrument as _instrument_impl  # noqa: PLC0415
-
-            _instrument = _instrument_impl
-        except ImportError as e:
-            error_msg = (
-                "The 'instrument' function requires additional dependencies. "
-                "Please install them with: pip install veris-ai[instrument]"
-            )
-            raise ImportError(error_msg) from e
-    return _instrument(*args, **kwargs)
-
-
-__all__ = ["veris", "JaegerClient", "instrument", "ResponseExpectation"]
+from .observability import init_observability, instrument_fastapi_app
+
+__all__ = [
+    "veris",
+    "JaegerClient",
+    "ResponseExpectation",
+    "init_observability",
+    "instrument_fastapi_app",
+]

veris_ai/jaeger_interface/__init__.py

@@ -34,6 +34,6 @@ are fully typed using *pydantic* models so that IDEs can provide proper
 autocomplete and type checking.
 """
 
-from .client import JaegerClient as JaegerClient  # noqa: F401
+from .client import JaegerClient
 
 __all__ = ["JaegerClient"]

veris_ai/logging.py

@@ -21,6 +21,7 @@ async def log_tool_call_async(
     if not base_url:
         logger.warning("VERIS_ENDPOINT_URL not set, skipping tool call logging")
         return
+    base_url = base_url.rstrip("/")
 
     endpoint = f"{base_url}/api/v2/simulations/{session_id}/log_tool_call"
     payload = {
@@ -32,8 +33,17 @@ async def log_tool_call_async(
     timeout = float(os.getenv("VERIS_MOCK_TIMEOUT", "90.0"))
 
     try:
+        headers: dict[str, str] | None = None
+        try:
+            from opentelemetry.propagate import get_global_textmap
+
+            headers = {}
+            get_global_textmap().inject(headers)
+        except Exception:  # pragma: no cover - otel optional
+            headers = None
+
         async with httpx.AsyncClient(timeout=timeout) as client:
-            response = await client.post(endpoint, json=payload)
+            response = await client.post(endpoint, json=payload, headers=headers)
             response.raise_for_status()
             logger.debug(f"Tool call logged for {function_name}")
     except Exception as e:
@@ -62,15 +72,24 @@ def log_tool_call_sync(
     timeout = float(os.getenv("VERIS_MOCK_TIMEOUT", "90.0"))
 
     try:
+        headers: dict[str, str] | None = None
+        try:
+            from opentelemetry.propagate import get_global_textmap  # type: ignore[import-not-found]
+
+            headers = {}
+            get_global_textmap().inject(headers)
+        except Exception:  # pragma: no cover - otel optional
+            headers = None
+
         with httpx.Client(timeout=timeout) as client:
-            response = client.post(endpoint, json=payload)
+            response = client.post(endpoint, json=payload, headers=headers)
             response.raise_for_status()
             logger.debug(f"Tool call logged for {function_name}")
     except Exception as e:
         logger.warning(f"Failed to log tool call for {function_name}: {e}")
 
 
-async def log_tool_response_async(session_id: str, response: object) -> None:
+async def log_tool_response_async(session_id: str, response: Any) -> None:  # noqa: ANN401
     """Log tool response asynchronously to the VERIS logging endpoint."""
     base_url = os.getenv("VERIS_ENDPOINT_URL")
     if not base_url:
@@ -85,15 +104,24 @@ async def log_tool_response_async(session_id: str, response: object) -> None:
     timeout = float(os.getenv("VERIS_MOCK_TIMEOUT", "90.0"))
 
     try:
+        headers: dict[str, str] | None = None
+        try:
+            from opentelemetry.propagate import get_global_textmap  # type: ignore[import-not-found]
+
+            headers = {}
+            get_global_textmap().inject(headers)
+        except Exception:  # pragma: no cover - otel optional
+            headers = None
+
         async with httpx.AsyncClient(timeout=timeout) as client:
-            http_response = await client.post(endpoint, json=payload)
+            http_response = await client.post(endpoint, json=payload, headers=headers)
             http_response.raise_for_status()
             logger.debug("Tool response logged")
     except Exception as e:
         logger.warning(f"Failed to log tool response: {e}")
 
 
-def log_tool_response_sync(session_id: str, response: object) -> None:
+def log_tool_response_sync(session_id: str, response: Any) -> None:  # noqa: ANN401
     """Log tool response synchronously to the VERIS logging endpoint."""
     base_url = os.getenv("VERIS_ENDPOINT_URL")
     if not base_url:
@@ -108,8 +136,17 @@ def log_tool_response_sync(session_id: str, response: object) -> None:
     timeout = float(os.getenv("VERIS_MOCK_TIMEOUT", "90.0"))
 
     try:
+        headers: dict[str, str] | None = None
+        try:
+            from opentelemetry.propagate import get_global_textmap  # type: ignore[import-not-found]
+
+            headers = {}
+            get_global_textmap().inject(headers)
+        except Exception:  # pragma: no cover - otel optional
+            headers = None
+
         with httpx.Client(timeout=timeout) as client:
-            http_response = client.post(endpoint, json=payload)
+            http_response = client.post(endpoint, json=payload, headers=headers)
             http_response.raise_for_status()
             logger.debug("Tool response logged")
     except Exception as e:

veris_ai/observability.py

@@ -0,0 +1,133 @@
+"""Observability helpers for services using veris-ai.
+
+Provides optional-safe initialization for OpenTelemetry propagation/export and
+client/server instrumentation. Services can import and call these helpers to
+enable consistent tracing without duplicating setup code.
+"""
+
+from __future__ import annotations
+
+import os
+
+from fastapi import FastAPI
+
+
+def init_observability(service_name: str | None = None) -> None:
+    """Initialize tracing/export and set W3C propagation.
+
+    - Initializes Traceloop if available (acts as OTel bootstrap/exporter)
+    - Sets global propagator to TraceContext + Baggage (W3C)
+    - Instruments MCP, requests, httpx if instrumentation packages are present
+    - Adds a request hook to capture outbound traceparent for debugging
+
+    This function is safe to call even if instrumentation packages are not installed.
+    """
+
+    resolved_service_name = service_name or os.getenv("VERIS_SERVICE_NAME", "veris-service")
+
+    # Initialize Traceloop SDK first (acts as OTel bootstrap)
+    try:
+        from traceloop.sdk import Traceloop  # type: ignore[import-not-found, import-untyped]
+
+        Traceloop.init(app_name=resolved_service_name, disable_batch=True)
+    except Exception as e:
+        # Tracing is optional; continue without Traceloop
+        msg = "Traceloop not found: " + str(e)
+        raise RuntimeError(msg) from e
+
+    # Ensure W3C propagation (TraceContext + optional Baggage), tolerant to OTel versions
+    try:
+        from opentelemetry.propagate import set_global_textmap
+        from opentelemetry.trace.propagation.tracecontext import TraceContextTextMapPropagator
+        from collections.abc import Mapping  # noqa: TC003
+        from opentelemetry.trace import Span
+        from requests import PreparedRequest
+        import httpx
+
+        # Import baggage propagator
+        baggage = None
+        try:
+            from opentelemetry.baggage.propagation import W3CBaggagePropagator
+
+            baggage = W3CBaggagePropagator()
+        except Exception as e:
+            msg = "OpenTelemetry not found: " + str(e)
+            raise RuntimeError(msg) from e
+
+        # Import composite propagator
+        try:
+            from opentelemetry.propagators.composite import CompositeHTTPPropagator
+
+            propagators: list[W3CBaggagePropagator | TraceContextTextMapPropagator] = [
+                TraceContextTextMapPropagator()
+            ]
+            if baggage:
+                propagators.append(baggage)
+            set_global_textmap(CompositeHTTPPropagator(propagators))
+        except Exception as e:
+            msg = "OpenTelemetry not found: " + str(e)
+            raise RuntimeError(msg) from e
+    except Exception as e:
+        # OpenTelemetry not installed or incompatible; continue without changing global propagator
+        msg = "OpenTelemetry not found: " + str(e)
+        raise RuntimeError(msg) from e
+
+    # Instrument HTTP clients and capture outbound traceparent for debugging
+    def _log_request_headers(
+        span: Span, request: PreparedRequest | httpx.Request | dict[str, Mapping[str, str]]
+    ) -> None:
+        try:
+            traceparent = None
+            if hasattr(request, "headers"):
+                traceparent = request.headers.get("traceparent")
+            elif isinstance(request, dict):
+                traceparent = request.get("headers", {}).get("traceparent")
+            if traceparent:
+                span.set_attribute("debug.traceparent", traceparent)
+        except Exception as e:
+            msg = "OpenTelemetry not found: " + str(e)
+            raise RuntimeError(msg) from e
+
+    try:
+        from opentelemetry.instrumentation.requests import (
+            RequestsInstrumentor,  # type: ignore[import-not-found]
+        )
+
+        RequestsInstrumentor().instrument(request_hook=_log_request_headers)
+    except Exception as e:
+        msg = "OpenTelemetry not found: " + str(e)
+        raise RuntimeError(msg) from e
+
+    try:
+        from opentelemetry.instrumentation.httpx import (
+            HTTPXClientInstrumentor,  # type: ignore[import-not-found]
+        )
+
+        HTTPXClientInstrumentor().instrument(request_hook=_log_request_headers)
+    except Exception as e:
+        msg = "OpenTelemetry not found: " + str(e)
+        raise RuntimeError(msg) from e
+
+    # Optionally enable MCP-specific spans
+    try:
+        from opentelemetry.instrumentation.mcp import McpInstrumentor  # type: ignore[import-not-found]
+
+        McpInstrumentor().instrument()
+    except Exception as e:
+        msg = "OpenTelemetry not found: " + str(e)
+        raise RuntimeError(msg) from e
+
+
+def instrument_fastapi_app(app: FastAPI) -> None:
+    """Instrument a FastAPI app so inbound HTTP requests continue W3C traces.
+
+    Safe to call even if the fastapi instrumentation package is not installed.
+    """
+
+    try:
+        from opentelemetry.instrumentation.fastapi import FastAPIInstrumentor  # type: ignore[import-not-found]
+
+        FastAPIInstrumentor.instrument_app(app)
+    except Exception as e:
+        msg = "OpenTelemetry not found: " + str(e)
+        raise RuntimeError(msg) from e

veris_ai/tool_mock.py

@@ -172,57 +172,82 @@ class VerisSDK:
                     # If not in simulation mode, execute the original function
                     return await func(*args, **kwargs)
 
-                # Handle spy mode - execute original function and log
-                if mode == "spy":
-                    logger.info(f"Spying on function: {func.__name__}")
-
-                    # Log the tool call
-                    sig = inspect.signature(func)
-                    bound_args = sig.bind(*args, **kwargs)
-                    bound_args.apply_defaults()
-                    _ = bound_args.arguments.pop("ctx", None)
-                    _ = bound_args.arguments.pop("self", None)
-                    _ = bound_args.arguments.pop("cls", None)
-
-                    await log_tool_call_async(
-                        session_id=self.session_id,
-                        function_name=func.__name__,
-                        parameters=bound_args.arguments,
-                        docstring=inspect.getdoc(func) or "",
-                    )
-
-                    # Execute the original function
-                    result = await func(*args, **kwargs)
-
-                    # Log the response
-                    await log_tool_response_async(session_id=self.session_id, response=result)
-
-                    return result
-
-                # Regular mock mode
-                base_url = os.getenv("VERIS_ENDPOINT_URL")
-                if not base_url:
-                    error_msg = "VERIS_ENDPOINT_URL environment variable is not set"
-                    raise ValueError(error_msg)
-                endpoint = f"{base_url.rstrip('/')}/api/v2/tool_mock"
-                # Default timeout of 30 seconds
-                timeout = float(os.getenv("VERIS_MOCK_TIMEOUT", "90.0"))
-
-                logger.info(f"Simulating function: {func.__name__}")
-                payload, return_type_obj = create_mock_payload(*args, **kwargs)
-
-                # Send request to endpoint with timeout
-                async with httpx.AsyncClient(timeout=timeout) as client:
-                    response = await client.post(endpoint, json=payload)
-                    response.raise_for_status()
-                    mock_result = response.json()
-                    logger.info(f"Mock response: {mock_result}")
-
-                if isinstance(mock_result, str):
-                    with suppress(json.JSONDecodeError):
-                        mock_result = json.loads(mock_result)
-                        return convert_to_type(mock_result, return_type_obj)
-                return convert_to_type(mock_result, return_type_obj)
+                async def _execute_mock_logic(session_id: str) -> object:
+                    # Handle spy mode - execute original function and log
+                    if mode == "spy":
+                        logger.info(f"Spying on function: {func.__name__}")
+
+                        # Log the tool call
+                        sig = inspect.signature(func)
+                        bound_args = sig.bind(*args, **kwargs)
+                        bound_args.apply_defaults()
+                        _ = bound_args.arguments.pop("ctx", None)
+                        _ = bound_args.arguments.pop("self", None)
+                        _ = bound_args.arguments.pop("cls", None)
+
+                        await log_tool_call_async(
+                            session_id=session_id,
+                            function_name=func.__name__,
+                            parameters=bound_args.arguments,
+                            docstring=inspect.getdoc(func) or "",
+                        )
+
+                        # Execute the original function
+                        result = await func(*args, **kwargs)
+
+                        # Log the response
+                        await log_tool_response_async(session_id=session_id, response=result)
+
+                        return result
+
+                    # Regular mock mode
+                    base_url = os.getenv("VERIS_ENDPOINT_URL")
+                    if not base_url:
+                        error_msg = "VERIS_ENDPOINT_URL environment variable is not set"
+                        raise ValueError(error_msg)
+                    endpoint = f"{base_url.rstrip('/')}/api/v2/tool_mock"
+                    # Default timeout of 30 seconds
+                    timeout = float(os.getenv("VERIS_MOCK_TIMEOUT", "90.0"))
+
+                    logger.info(f"Simulating function: {func.__name__}")
+                    payload, return_type_obj = create_mock_payload(*args, **kwargs)
+
+                    # Send request to endpoint with timeout
+                    # Inject current trace context headers if OpenTelemetry is available
+                    headers: dict[str, str] | None = None
+                    try:
+                        from opentelemetry.propagate import get_global_textmap  # type: ignore[import-not-found]
+
+                        headers = {}
+                        get_global_textmap().inject(headers)
+                    except Exception:  # pragma: no cover - otel optional
+                        headers = None
+
+                    async with httpx.AsyncClient(timeout=timeout) as client:
+                        response = await client.post(endpoint, json=payload, headers=headers)
+                        response.raise_for_status()
+                        mock_result = response.json()
+                        logger.info(f"Mock response: {mock_result}")
+
+                    if isinstance(mock_result, str):
+                        with suppress(json.JSONDecodeError):
+                            mock_result = json.loads(mock_result)
+                            return convert_to_type(mock_result, return_type_obj)
+                    return convert_to_type(mock_result, return_type_obj)
+
+                # Create a top-level span for the simulated mock call if OpenTelemetry is available
+                try:
+                    from opentelemetry import trace  # type: ignore[import-not-found]
+
+                    tracer = trace.get_tracer("veris_ai.tool_mock")
+                    span_name = f"mock.{func.__name__}"
+                    with tracer.start_as_current_span(span_name) as span:  # type: ignore[attr-defined]
+                        span.set_attribute("veris_ai.session.id", self.session_id or "")  # type: ignore[attr-defined]
+                        span.set_attribute("veris_ai.mock.mode", mode)  # type: ignore[attr-defined]
+                        return await _execute_mock_logic(self.session_id)
+                except Exception:
+                    # If OpenTelemetry is not available, run without span
+                    return await _execute_mock_logic(self.session_id)
 
             @wraps(func)
             def sync_wrapper(
@@ -234,57 +259,82 @@ class VerisSDK:
                     # If not in simulation mode, execute the original function
                     return func(*args, **kwargs)
 
-                # Handle spy mode - execute original function and log
-                if mode == "spy":
-                    logger.info(f"Spying on function: {func.__name__}")
-
-                    # Log the tool call
-                    sig = inspect.signature(func)
-                    bound_args = sig.bind(*args, **kwargs)
-                    bound_args.apply_defaults()
-                    _ = bound_args.arguments.pop("ctx", None)
-                    _ = bound_args.arguments.pop("self", None)
-                    _ = bound_args.arguments.pop("cls", None)
-
-                    log_tool_call_sync(
-                        session_id=self.session_id,
-                        function_name=func.__name__,
-                        parameters=bound_args.arguments,
-                        docstring=inspect.getdoc(func) or "",
-                    )
-
-                    # Execute the original function
-                    result = func(*args, **kwargs)
-
-                    # Log the response
-                    log_tool_response_sync(session_id=self.session_id, response=result)
-
-                    return result
-
-                # Regular mock mode
-                base_url = os.getenv("VERIS_ENDPOINT_URL")
-                if not base_url:
-                    error_msg = "VERIS_ENDPOINT_URL environment variable is not set"
-                    raise ValueError(error_msg)
-                endpoint = f"{base_url.rstrip('/')}/api/v2/tool_mock"
-                # Default timeout of 30 seconds
-                timeout = float(os.getenv("VERIS_MOCK_TIMEOUT", "90.0"))
-
-                logger.info(f"Simulating function: {func.__name__}")
-                payload, return_type_obj = create_mock_payload(*args, **kwargs)
-
-                # Send request to endpoint with timeout (synchronous)
-                with httpx.Client(timeout=timeout) as client:
-                    response = client.post(endpoint, json=payload)
-                    response.raise_for_status()
-                    mock_result = response.json()
-                    logger.info(f"Mock response: {mock_result}")
-
-                if isinstance(mock_result, str):
-                    with suppress(json.JSONDecodeError):
-                        mock_result = json.loads(mock_result)
-                        return convert_to_type(mock_result, return_type_obj)
-                return convert_to_type(mock_result, return_type_obj)
+                def _execute_mock_logic(session_id: str) -> object:
+                    # Handle spy mode - execute original function and log
+                    if mode == "spy":
+                        logger.info(f"Spying on function: {func.__name__}")
+
+                        # Log the tool call
+                        sig = inspect.signature(func)
+                        bound_args = sig.bind(*args, **kwargs)
+                        bound_args.apply_defaults()
+                        _ = bound_args.arguments.pop("ctx", None)
+                        _ = bound_args.arguments.pop("self", None)
+                        _ = bound_args.arguments.pop("cls", None)
+
+                        log_tool_call_sync(
+                            session_id=session_id,
+                            function_name=func.__name__,
+                            parameters=bound_args.arguments,
+                            docstring=inspect.getdoc(func) or "",
+                        )
+
+                        # Execute the original function
+                        result = func(*args, **kwargs)
+
+                        # Log the response
+                        log_tool_response_sync(session_id=session_id, response=result)
+
+                        return result
+
+                    # Regular mock mode
+                    base_url = os.getenv("VERIS_ENDPOINT_URL")
+                    if not base_url:
+                        error_msg = "VERIS_ENDPOINT_URL environment variable is not set"
+                        raise ValueError(error_msg)
+                    endpoint = f"{base_url.rstrip('/')}/api/v2/tool_mock"
+                    # Default timeout of 30 seconds
+                    timeout = float(os.getenv("VERIS_MOCK_TIMEOUT", "90.0"))
+
+                    logger.info(f"Simulating function: {func.__name__}")
+                    payload, return_type_obj = create_mock_payload(*args, **kwargs)
+
+                    # Send request to endpoint with timeout (synchronous)
+                    # Inject current trace context headers if OpenTelemetry is available
+                    headers: dict[str, str] | None = None
+                    try:
+                        from opentelemetry.propagate import get_global_textmap  # type: ignore[import-not-found]
+
+                        headers = {}
+                        get_global_textmap().inject(headers)
+                    except Exception:  # pragma: no cover - otel optional
+                        headers = None
+
+                    with httpx.Client(timeout=timeout) as client:
+                        response = client.post(endpoint, json=payload, headers=headers)
+                        response.raise_for_status()
+                        mock_result = response.json()
+                        logger.info(f"Mock response: {mock_result}")
+
+                    if isinstance(mock_result, str):
+                        with suppress(json.JSONDecodeError):
+                            mock_result = json.loads(mock_result)
+                            return convert_to_type(mock_result, return_type_obj)
+                    return convert_to_type(mock_result, return_type_obj)
+
+                # Create a top-level span for the simulated mock call if OpenTelemetry is available
+                try:
+                    from opentelemetry import trace  # type: ignore[import-not-found]
+
+                    tracer = trace.get_tracer("veris_ai.tool_mock")
+                    span_name = f"mock.{func.__name__}"
+                    with tracer.start_as_current_span(span_name) as span:  # type: ignore[attr-defined]
+                        span.set_attribute("veris_ai.session.id", self.session_id or "")  # type: ignore[attr-defined]
+                        span.set_attribute("veris_ai.mock.mode", mode)  # type: ignore[attr-defined]
+                        return _execute_mock_logic(self.session_id)
+                except Exception:
+                    # If OpenTelemetry is not available, run without span
+                    return _execute_mock_logic(self.session_id)
 
             # Return the appropriate wrapper based on whether the function is async
             return async_wrapper if is_async else sync_wrapper

{veris_ai-1.5.0.dist-info → veris_ai-1.7.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: veris-ai
-Version: 1.5.0
+Version: 1.7.0
 Summary: A Python package for Veris AI tools
 Project-URL: Homepage, https://github.com/veris-ai/veris-python-sdk
 Project-URL: Bug Tracker, https://github.com/veris-ai/veris-python-sdk/issues
@@ -9,8 +9,17 @@ License-Expression: MIT
 License-File: LICENSE
 Requires-Python: >=3.11
 Requires-Dist: httpx>=0.24.0
+Requires-Dist: opentelemetry-api>=1.34.1
+Requires-Dist: opentelemetry-exporter-otlp>=1.34.1
+Requires-Dist: opentelemetry-instrumentation-fastapi>=0.55b1
+Requires-Dist: opentelemetry-instrumentation-httpx>=0.55b1
+Requires-Dist: opentelemetry-instrumentation-mcp>=0.44.1
+Requires-Dist: opentelemetry-instrumentation-requests>=0.55b1
+Requires-Dist: opentelemetry-instrumentation>=0.55b1
+Requires-Dist: opentelemetry-sdk>=1.34.1
 Requires-Dist: pydantic>=2.0.0
 Requires-Dist: requests>=2.31.0
+Requires-Dist: traceloop-sdk>=0.45.4
 Provides-Extra: dev
 Requires-Dist: black>=23.7.0; extra == 'dev'
 Requires-Dist: mypy>=1.5.1; extra == 'dev'
@@ -24,12 +33,7 @@ Provides-Extra: fastapi
 Requires-Dist: fastapi; extra == 'fastapi'
 Requires-Dist: fastapi-mcp>=0.4.0; extra == 'fastapi'
 Provides-Extra: instrument
-Requires-Dist: braintrust; extra == 'instrument'
 Requires-Dist: opentelemetry-api; extra == 'instrument'
-Requires-Dist: opentelemetry-exporter-otlp; extra == 'instrument'
-Requires-Dist: opentelemetry-exporter-otlp-proto-common; extra == 'instrument'
-Requires-Dist: opentelemetry-exporter-otlp-proto-grpc; extra == 'instrument'
-Requires-Dist: opentelemetry-exporter-otlp-proto-http; extra == 'instrument'
 Requires-Dist: opentelemetry-sdk; extra == 'instrument'
 Requires-Dist: wrapt; extra == 'instrument'
 Description-Content-Type: text/markdown
@@ -41,7 +45,7 @@ A Python package for Veris AI tools with simulation capabilities and FastAPI MCP
 ## Quick Reference
 
 **Purpose**: Tool mocking, tracing, and FastAPI MCP integration for AI agent development  
-**Core Components**: [`tool_mock`](#function-mocking) • [`jaeger_interface`](#jaeger-trace-interface) • [`braintrust_tracing`](#tracing-integration) • [`fastapi_mcp`](#fastapi-mcp-integration)  
+**Core Components**: [`tool_mock`](#function-mocking) • [`observability`](#sdk-observability-helpers) • [`fastapi_mcp`](#fastapi-mcp-integration) • [`jaeger_interface`](#jaeger-trace-interface)  
 **Deep Dive**: [`Module Architecture`](src/veris_ai/README.md) • [`Testing Guide`](tests/README.md) • [`Usage Examples`](examples/README.md)  
 **Source of Truth**: Implementation details in [`src/veris_ai/`](src/veris_ai/) source code
 
@@ -58,7 +62,7 @@ uv add "veris-ai[dev,fastapi,instrument]"
 **Installation Profiles**:
 - `dev`: Development tools (ruff, pytest, mypy) 
 - `fastapi`: FastAPI MCP integration
-- `instrument`: Braintrust/OpenTelemetry tracing
+- `observability`: OpenTelemetry tracing
 
 ## Import Patterns
 
@@ -69,7 +73,7 @@ uv add "veris-ai[dev,fastapi,instrument]"
 from veris_ai import veris, JaegerClient
 
 # Optional features (require extras)
-from veris_ai import braintrust_tracing  # Requires [instrument]
+from veris_ai import init_observability, instrument_fastapi_app  # Provided by SDK observability helpers
 ```
 
 **Complete Import Strategies**: See [`examples/README.md`](examples/README.md) for five different import approaches, conditional features, and integration patterns.
@@ -88,22 +92,33 @@ from veris_ai import braintrust_tracing  # Requires [instrument]
 
 **Configuration Details**: See [`src/veris_ai/tool_mock.py`](src/veris_ai/tool_mock.py) for environment handling logic.
 
-## Tracing Integration
 
-**Semantic Tag**: `distributed-tracing`
+### SDK Observability Helpers
 
-Parallel tracing to Braintrust and Jaeger/OpenTelemetry for monitoring and evaluation.
+The SDK provides optional-safe observability helpers that standardize OpenTelemetry setup and W3C context propagation across services.
 
 ```python
-from veris_ai import braintrust_tracing
+from fastapi import FastAPI
+from veris_ai import init_observability, instrument_fastapi_app
+
+# Initialize tracing/export early (no-op if dependencies are absent)
+init_observability(service_name="my-customer-service")
+
+app = FastAPI()
 
-# Enable dual tracing
-braintrust_tracing.instrument(service_name="my-service", otlp_endpoint="http://localhost:4317")
+# Ensure inbound HTTP requests continue W3C traces
+instrument_fastapi_app(app)
 ```
 
-**Session Management**: Automatic session ID extraction from bearer tokens. Manual session control via `veris.set_session_id()` and `veris.clear_session_id()`.
+What this enables:
+- Sets global W3C propagator (TraceContext + Baggage)
+- Optionally instruments FastAPI, requests, httpx, MCP client if installed
+- Includes request hooks to attach outbound `traceparent` on HTTP calls for continuity
 
-**Implementation Details**: See [`src/veris_ai/braintrust_tracing.py`](src/veris_ai/braintrust_tracing.py) for instrumentation logic.
+End-to-end propagation with the simulator:
+- The simulator injects W3C headers when connecting to your FastAPI MCP endpoints
+- The SDK injects W3C headers on `/api/v2/tool_mock` and logging requests back to the simulator
+- Result: customer agent spans and tool mocks appear under the same distributed trace
 
 ## Function Mocking
 
@@ -207,7 +222,7 @@ pytest --cov=veris_ai # Test with coverage
 
 **Semantic Tag**: `module-architecture`
 
-**Core Modules**: `tool_mock` (mocking), `jaeger_interface` (trace queries), `braintrust_tracing` (dual tracing), `utils` (schema conversion)
+**Core Modules**: `tool_mock` (mocking), `jaeger_interface` (trace queries), `utils` (schema conversion)
 
 **Complete Architecture**: See [`src/veris_ai/README.md`](src/veris_ai/README.md) for module overview, implementation flows, and configuration details. 
 

veris_ai-1.7.0.dist-info/RECORD

@@ -0,0 +1,15 @@
+veris_ai/README.md,sha256=iMSwSIrBO2zEdUhImkhZucUnTNO0kSQ-_zxWjZCmp4I,2730
+veris_ai/__init__.py,sha256=Gh52-XfFpsxX37uqp8vuX0V3Np7f-Rlf5k3MMANu6e0,425
+veris_ai/logging.py,sha256=srEdVimcQSCsnwGhyzCydehD2JW1cQmwSRd3X20NQs0,5233
+veris_ai/models.py,sha256=6HINPxNFCakCVPcyEbUswWkXwb2K4lF0A8g8EvTMal4,213
+veris_ai/observability.py,sha256=fG5ixAiVDykLCdHUScKQNCsePLphKQ7PcaKkAGBVdF0,5113
+veris_ai/tool_mock.py,sha256=C1BANT3LCMKOIwJm_nOFuNdHnaO9_tbjeDTtBcI41RI,16512
+veris_ai/utils.py,sha256=aqFFNuNiBehil6874nOHtU7G_bWHbFpVuubcz2AIx6I,9267
+veris_ai/jaeger_interface/README.md,sha256=kd9rKcE5xf3EyNaiHu0tjn-0oES9sfaK6Ih-OhhTyCM,2821
+veris_ai/jaeger_interface/__init__.py,sha256=KD7NSiMYRG_2uF6dOLKkGG5lNQe4K9ptEwucwMT4_aw,1128
+veris_ai/jaeger_interface/client.py,sha256=yJrh86wRR0Dk3Gq12DId99WogcMIVbL0QQFqVSevvlE,8772
+veris_ai/jaeger_interface/models.py,sha256=e64VV6IvOEFuzRUgvDAMQFyOZMRb56I-PUPZLBZ3rX0,1864
+veris_ai-1.7.0.dist-info/METADATA,sha256=dmWFBpwU2MK9tjnJtlrkQdqnR9C0yn0Lhb1TMWb-XvA,8679
+veris_ai-1.7.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+veris_ai-1.7.0.dist-info/licenses/LICENSE,sha256=2g4i20atAgtD5einaKzhQrIB-JrPhyQgD3bC0wkHcCI,1065
+veris_ai-1.7.0.dist-info/RECORD,,

veris_ai/braintrust_tracing.py

@@ -1,282 +0,0 @@
-"""Non-invasive Braintrust + Jaeger (OTEL) instrumentation helper for the `openai-agents` SDK.
-
-Typical usage
--------------
->>> from our_sdk import braintrust_tracing
->>> braintrust_tracing.instrument(service_name="openai-agent")
-
-After calling :func:`instrument`, any later call to
-``agents.set_trace_processors([...])`` will be transparently patched so that:
-  • the list always contains a BraintrustTracingProcessor (for Braintrust UI)
-  • *and* an OpenTelemetry bridge processor that mirrors every span to the
-    global OTEL tracer provider (Jaeger by default).
-
-Goal: deliver full OTEL compatibility while keeping the official Braintrust
-SDK integration unchanged – **no code modifications required** besides the
-single `instrument()` call.
-"""
-
-from __future__ import annotations
-
-import json
-import logging
-import os
-from typing import Any, cast
-
-import wrapt  # type: ignore[import-untyped, import-not-found]
-from braintrust.wrappers.openai import (
-    BraintrustTracingProcessor,  # type: ignore[import-untyped, import-not-found]
-)
-from opentelemetry import context as otel_context  # type: ignore[import-untyped, import-not-found]
-from opentelemetry import trace  # type: ignore[import-untyped, import-not-found]
-from opentelemetry.exporter.otlp.proto.grpc.trace_exporter import (
-    OTLPSpanExporter,  # type: ignore[import-untyped, import-not-found]
-)
-from opentelemetry.sdk.resources import (  # type: ignore[import-untyped, import-not-found]
-    SERVICE_NAME,
-    Resource,
-)
-from opentelemetry.sdk.trace import TracerProvider  # type: ignore[import-untyped, import-not-found]
-from opentelemetry.sdk.trace.export import (
-    BatchSpanProcessor,  # type: ignore[import-untyped, import-not-found]
-)
-from opentelemetry.trace import SpanKind  # type: ignore[import-untyped, import-not-found]
-
-from veris_ai.tool_mock import _session_id_context
-
-# ---------------------------------------------------------------------------
-#  Optional import of *agents* – we fail lazily at runtime if missing.
-# ---------------------------------------------------------------------------
-try:
-    import agents  # type: ignore[import-untyped]  # noqa: TC002
-    from agents import TracingProcessor  # type: ignore[import-untyped]
-
-    try:
-        from agents.tracing import get_trace_provider  # type: ignore[import-untyped]
-    except ImportError:
-        # Fallback for newer versions that have GLOBAL_TRACE_PROVIDER instead
-        from agents.tracing import (  # type: ignore[import-untyped, attr-defined, import-not-found]
-            GLOBAL_TRACE_PROVIDER,  # type: ignore[import-untyped, attr-defined, import-not-found]
-        )
-
-        get_trace_provider = lambda: GLOBAL_TRACE_PROVIDER  # type: ignore[no-any-return]  # noqa: E731
-except ModuleNotFoundError as exc:  # pragma: no cover
-    _IMPORT_ERR: ModuleNotFoundError | None = exc
-    TracingProcessor = object  # type: ignore[assignment, misc]
-    get_trace_provider = None  # type: ignore[assignment]
-else:
-    _IMPORT_ERR = None
-
-__all__ = ["instrument"]
-
-logger = logging.getLogger(__name__)
-
-# ---------------------------------------------------------------------------
-#  Internal helper – OTEL bridge processor
-# ---------------------------------------------------------------------------
-
-
-class AgentsOTELBridgeProcessor(TracingProcessor):  # type: ignore[misc]
-    """Mirrors every Agents span into a dedicated OTEL tracer provider."""
-
-    def __init__(
-        self,
-        braintrust_processor: BraintrustTracingProcessor,
-        *,
-        service_name: str,  # noqa: ARG002
-        tracer_provider: trace.TracerProvider,
-    ) -> None:  # noqa: D401,E501
-        self._braintrust = braintrust_processor
-        self._tracer = tracer_provider.get_tracer(__name__)
-        self._otel_spans: dict[str, trace.Span] = {}
-        self._provider = tracer_provider
-
-    # ----------------------------- utils ---------------------------------
-    @staticmethod
-    def _flatten(prefix: str, obj: Any, out: dict[str, Any]) -> None:  # noqa: PLR0911, ANN401
-        """Flatten complex objects into OTEL-compatible primitives."""
-        if isinstance(obj, dict):
-            for k, v in obj.items():
-                AgentsOTELBridgeProcessor._flatten(f"{prefix}.{k}" if prefix else str(k), v, out)
-        elif isinstance(obj, str | int | float | bool) or obj is None:
-            out[prefix] = obj
-        elif isinstance(obj, list | tuple):
-            try:
-                if all(isinstance(i, str | int | float | bool) or i is None for i in obj):
-                    out[prefix] = list(obj)
-                else:
-                    out[prefix] = json.dumps(obj, default=str)
-            except Exception:  # pragma: no cover – defensive
-                out[prefix] = json.dumps(obj, default=str)
-        else:
-            out[prefix] = str(obj)
-
-    def _log_data_attributes(self, span_obj: agents.tracing.Span) -> dict[str, Any]:  # type: ignore[name-defined]
-        data = self._braintrust._log_data(span_obj)  # pyright: ignore[reportPrivateUsage]  # noqa: SLF001
-        flat: dict[str, Any] = {}
-        self._flatten("bt", data, flat)
-
-        # Add session_id if available
-        session_id = _session_id_context.get()
-        if session_id:
-            flat["veris.session_id"] = session_id
-
-        return {k: v for k, v in flat.items() if v is not None}
-
-    # --------------------- Agents lifecycle hooks ------------------------
-    def on_trace_start(self, trace_obj: Any) -> None:  # noqa: ANN401, D102
-        # Get session_id at trace start
-        session_id = _session_id_context.get()
-        attributes = {"veris.session_id": session_id} if session_id else {}
-
-        otel_span = self._tracer.start_span(
-            name=trace_obj.name or "agent-trace",
-            kind=SpanKind.INTERNAL,
-            attributes=attributes,
-        )
-        self._otel_spans[trace_obj.trace_id] = otel_span
-        logger.info(f"VERIS AI BraintrustTracingProcessor: on_trace_start: {trace_obj.trace_id}")
-
-    def on_trace_end(self, trace_obj: Any) -> None:  # noqa: ANN401, D102
-        span = self._otel_spans.pop(trace_obj.trace_id, None)
-        if span:
-            span.end()
-
-    def on_span_start(self, span: Any) -> None:  # noqa: ANN401, D102
-        parent_otel = (
-            self._otel_spans.get(span.parent_id)
-            if span.parent_id
-            else self._otel_spans.get(span.trace_id)
-        )
-        parent_ctx = (
-            trace.set_span_in_context(parent_otel) if parent_otel else otel_context.get_current()
-        )
-
-        # Get session_id at span start
-        session_id = _session_id_context.get()
-        attributes = {"veris.session_id": session_id} if session_id else {}
-
-        child = self._tracer.start_span(
-            name=span.span_data.__class__.__name__,
-            context=parent_ctx,
-            kind=SpanKind.INTERNAL,
-            attributes=attributes,
-        )
-        self._otel_spans[span.span_id] = child
-        logger.info(f"VERIS AI BraintrustTracingProcessor: on_span_start: {span.span_id}")
-
-    def on_span_end(self, span: Any) -> None:  # noqa: ANN401, D102
-        child = self._otel_spans.pop(span.span_id, None)
-        logger.info(f"VERIS AI BraintrustTracingProcessor: on_span_end: {span.span_id}")
-        if child:
-            for k, v in self._log_data_attributes(span).items():
-                try:
-                    child.set_attribute(k, v)
-                except Exception:  # pragma: no cover – bad value type  # noqa: S112
-                    continue
-            child.end()
-
-    # --------------------- house-keeping ---------------------------------
-    def shutdown(self) -> None:  # noqa: D401
-        provider = cast("TracerProvider", self._provider)
-        provider.shutdown()  # type: ignore[attr-defined]
-
-    def force_flush(self) -> None:  # noqa: D401
-        provider = cast("TracerProvider", self._provider)
-        provider.force_flush()  # type: ignore[attr-defined]
-
-
-# ---------------------------------------------------------------------------
-#  Public entry point
-# ---------------------------------------------------------------------------
-
-_PATCHED: bool = False  # ensure idempotent patching
-
-
-def instrument(
-    *,
-    service_name: str | None = None,
-    otlp_endpoint: str | None = None,
-) -> None:
-    """Bootstrap Braintrust + OTEL instrumentation and patch Agents SDK.
-
-    Invoke once at any point before `set_trace_processors` is called.
-    """
-    global _PATCHED  # noqa: PLW0603
-    if _PATCHED:
-        return  # already done
-
-    if _IMPORT_ERR is not None or get_trace_provider is None:  # pragma: no cover
-        error_msg = "The `agents` package is required but not installed"
-        raise RuntimeError(error_msg) from _IMPORT_ERR
-
-    # ------------------ 0. Validate inputs -----------------------------
-    # Resolve service name ─ explicit argument → env var → error
-    if not service_name or not str(service_name).strip():
-        service_name = os.getenv("VERIS_SERVICE_NAME")
-
-    if not service_name or not str(service_name).strip():
-        error_msg = (
-            "`service_name` must be provided either as an argument or via the "
-            "VERIS_SERVICE_NAME environment variable"
-        )
-        raise ValueError(error_msg)
-
-    # Resolve OTLP endpoint ─ explicit argument → env var → error
-    if not otlp_endpoint or not str(otlp_endpoint).strip():
-        otlp_endpoint = os.getenv("VERIS_OTLP_ENDPOINT")
-
-    if not otlp_endpoint or not str(otlp_endpoint).strip():
-        error_msg = (
-            "`otlp_endpoint` must be provided either as an argument or via the "
-            "VERIS_OTLP_ENDPOINT environment variable"
-        )
-        raise ValueError(error_msg)
-
-    logger.info(f"service_name: {service_name}")
-    logger.info(f"otlp_endpoint: {otlp_endpoint}")
-
-    # ------------------ 1. Configure OTEL provider ---------------------
-    # We create our own provider instance and do NOT set it globally.
-    # This avoids conflicts with any other OTEL setup in the application.
-    otel_provider = TracerProvider(resource=Resource.create({SERVICE_NAME: service_name}))
-    otel_provider.add_span_processor(
-        BatchSpanProcessor(OTLPSpanExporter(endpoint=otlp_endpoint, insecure=True)),
-    )
-
-    # ------------------ 2. Define wrapper for patching -------------------
-    def _wrapper(wrapped: Any, instance: Any, args: Any, kwargs: Any) -> Any:  # noqa: ANN401, ARG001
-        """This function wraps `TraceProvider.set_processors`."""
-        processors = args[0] if args else []
-
-        # Find the user's Braintrust processor to pass to our bridge.
-        bt_processor = next(
-            (p for p in processors if isinstance(p, BraintrustTracingProcessor)), None
-        )
-
-        # If no Braintrust processor is present, our bridge is useless.
-        # Also, if a bridge is already there, don't add another one.
-        has_bridge = any(isinstance(p, AgentsOTELBridgeProcessor) for p in processors)
-        if not bt_processor or has_bridge:
-            return wrapped(*args, **kwargs)
-
-        # Create the bridge and add it to the list of processors.
-        bridge = AgentsOTELBridgeProcessor(
-            bt_processor,
-            service_name=service_name,
-            tracer_provider=otel_provider,
-        )
-        new_processors = list(processors) + [bridge]
-
-        # Call the original function with the augmented list.
-        new_args = (new_processors,) + args[1:]
-        logger.info(f"VERIS AI BraintrustTracingProcessor: {new_args}")
-        return wrapped(*new_args, **kwargs)
-
-    # ------------------ 3. Patch the provider instance -------------------
-    # This is more robust than patching the function, as it's independent
-    # of how the user imports `set_trace_processors`.
-    provider_instance = get_trace_provider()
-    wrapt.wrap_function_wrapper(provider_instance, "set_processors", _wrapper)
-
-    _PATCHED = True

veris_ai-1.5.0.dist-info/RECORD

@@ -1,15 +0,0 @@
-veris_ai/README.md,sha256=q0Qn6gu85HWU189SmyOygY_mkNj0l10wlAVy9kj4udo,3120
-veris_ai/__init__.py,sha256=Vp5yf9ZRchw0mmPwrRuNebI5cb2NGwpJGfr41l86q1U,1177
-veris_ai/braintrust_tracing.py,sha256=0i-HR6IuK3-Q5ujMjT1FojxESRZLgqEvJ44bfJfDHaw,11938
-veris_ai/logging.py,sha256=2855E8s_k6yTnzFK10EQR4WQngQk3VuWFPJW-MYiw3k,3837
-veris_ai/models.py,sha256=6HINPxNFCakCVPcyEbUswWkXwb2K4lF0A8g8EvTMal4,213
-veris_ai/tool_mock.py,sha256=p10k6dCZAIqG8YoefR3QyvtkInnWNPMRO_07LI5Wks0,13218
-veris_ai/utils.py,sha256=aqFFNuNiBehil6874nOHtU7G_bWHbFpVuubcz2AIx6I,9267
-veris_ai/jaeger_interface/README.md,sha256=kd9rKcE5xf3EyNaiHu0tjn-0oES9sfaK6Ih-OhhTyCM,2821
-veris_ai/jaeger_interface/__init__.py,sha256=d873a0zq3eUYU2Y77MtdjCwIARjAsAP7WDqGXDMWpYs,1158
-veris_ai/jaeger_interface/client.py,sha256=yJrh86wRR0Dk3Gq12DId99WogcMIVbL0QQFqVSevvlE,8772
-veris_ai/jaeger_interface/models.py,sha256=e64VV6IvOEFuzRUgvDAMQFyOZMRb56I-PUPZLBZ3rX0,1864
-veris_ai-1.5.0.dist-info/METADATA,sha256=l-x_bBgu3DWDVgG4IFeek26y1U1ANP6F4Cz-yrm9beQ,8151
-veris_ai-1.5.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-veris_ai-1.5.0.dist-info/licenses/LICENSE,sha256=2g4i20atAgtD5einaKzhQrIB-JrPhyQgD3bC0wkHcCI,1065
-veris_ai-1.5.0.dist-info/RECORD,,