ioa-observe-sdk 1.0.15__py3-none-any.whl → 1.0.16__py3-none-any.whl

ioa_observe/sdk/__init__.py

@@ -89,7 +89,7 @@ class Observe:
 
         if (
             observe_sync_enabled
-            and api_endpoint.find("observe.com") != -1
+            and api_endpoint.find("agntcy-observe.com") != -1
             and api_key
             and (exporter is None)
             and (processor is None)
@@ -112,13 +112,13 @@ class Observe:
         if (
             not exporter
             and not processor
-            and api_endpoint == "https://api.observe.com"
+            and api_endpoint == "https://api.agntcy-observe.com"
             and not api_key
         ):
             print(
                 Fore.RED
                 + "Error: Missing observe API key,"
-                + " go to https://app.observe.com/settings/api-keys to create one"
+                + " go to https://app.agntcy-observe.com/settings/api-keys to create one"
             )
             print("Set the OBSERVE_API_KEY environment variable to the key")
             print(Fore.RESET)

ioa_observe/sdk/client/client.py

@@ -27,7 +27,7 @@ class Client:
         self,
         api_key: str,
         app_name: str = sys.argv[0],
-        api_endpoint: str = "https://api.observe.com",
+        api_endpoint: str = "https://api.agntcy-observe.com",
     ):
         """
         Initialize a new observe client.
@@ -35,13 +35,13 @@ class Client:
         Args:
             api_key (str): Your observe API key
             app_name (Optional[str], optional): The name of your application. Defaults to sys.argv[0].
-            api_endpoint (Optional[str], optional): Custom API endpoint. Defaults to https://api.observe.com.
+            api_endpoint (Optional[str], optional): Custom API endpoint. Defaults to https://api.agntcy-observe.com.
         """
         if not api_key or not api_key.strip():
             raise ValueError("API key is required")
 
         self.app_name = app_name
-        self.api_endpoint = api_endpoint or "https://api.observe.com"
+        self.api_endpoint = api_endpoint or "https://api.agntcy-observe.com"
         self.api_key = api_key
         self._http = HTTPClient(
             base_url=self.api_endpoint, api_key=self.api_key, version=__version__

ioa_observe/sdk/decorators/__init__.py

@@ -1,7 +1,7 @@
 # Copyright AGNTCY Contributors (https://github.com/agntcy)
 # SPDX-License-Identifier: Apache-2.0
 import inspect
-from typing import Optional, Union, TypeVar, Callable, Awaitable
+from typing import Optional, Union, TypeVar, Callable, Any
 
 from typing_extensions import ParamSpec
 
@@ -14,7 +14,7 @@ from ioa_observe.sdk.utils.const import ObserveSpanKindValues
 
 P = ParamSpec("P")
 R = TypeVar("R")
-F = TypeVar("F", bound=Callable[P, Union[R, Awaitable[R]]])
+F = TypeVar("F", bound=Callable[..., Any])
 
 
 def task(

ioa_observe/sdk/decorators/base.py

@@ -7,7 +7,7 @@ import traceback
 from functools import wraps
 import os
 import types
-from typing import Optional, TypeVar, Callable, Awaitable, Any, Union
+from typing import Optional, TypeVar, Callable, Any
 import inspect
 
 from ioa_observe.sdk.decorators.helpers import (
@@ -53,7 +53,7 @@ from ioa_observe.sdk.metrics.agent import topology_dynamism, determinism_score
 P = ParamSpec("P")
 
 R = TypeVar("R")
-F = TypeVar("F", bound=Callable[P, Union[R, Awaitable[R]]])
+F = TypeVar("F", bound=Callable[..., Any])
 
 
 def _is_json_size_valid(json_str: str) -> bool:

ioa_observe/sdk/instrumentations/a2a.py

@@ -14,7 +14,7 @@ from ioa_observe.sdk import TracerWrapper
 from ioa_observe.sdk.client import kv_store
 from ioa_observe.sdk.tracing import set_session_id, get_current_traceparent
 
-_instruments = ("a2a-sdk >= 0.2.5",)
+_instruments = ("a2a-sdk >= 0.3.0",)
 _global_tracer = None
 _kv_lock = threading.RLock()  # Add thread-safety for kv_store operations
 
@@ -34,15 +34,14 @@ class A2AInstrumentor(BaseInstrumentor):
         if importlib.util.find_spec("a2a") is None:
             raise ImportError("No module named 'a2a-sdk'. Please install it first.")
 
-        # Instrument `publish`
+        # Instrument client send_message
         from a2a.client import A2AClient
 
         original_send_message = A2AClient.send_message
 
         @functools.wraps(original_send_message)
-        async def instrumented_send_message(
-            self, request, *, http_kwargs=None, context=None
-        ):
+        async def instrumented_send_message(self, request, *args, **kwargs):
+            # Put context into A2A message metadata instead of HTTP headers
             with _global_tracer.start_as_current_span("a2a.send_message"):
                 traceparent = get_current_traceparent()
                 session_id = None
@@ -50,47 +49,101 @@ class A2AInstrumentor(BaseInstrumentor):
                     session_id = kv_store.get(f"execution.{traceparent}")
                     if session_id:
                         kv_store.set(f"execution.{traceparent}", session_id)
-                # Inject headers into http_kwargs
-                if http_kwargs is None:
-                    http_kwargs = {}
-                headers = http_kwargs.get("headers", {})
-                headers["traceparent"] = traceparent
+
+                # Ensure metadata dict exists
+                try:
+                    md = getattr(request.params, "metadata", None)
+                except AttributeError:
+                    md = None
+                metadata = md if isinstance(md, dict) else {}
+
+                observe_meta = dict(metadata.get("observe", {}))
+
+                # Inject W3C trace context + baggage into observe_meta
+                TraceContextTextMapPropagator().inject(carrier=observe_meta)
+                W3CBaggagePropagator().inject(carrier=observe_meta)
+
+                if traceparent:
+                    observe_meta["traceparent"] = traceparent
                 if session_id:
-                    headers["session_id"] = session_id
+                    observe_meta["session_id"] = session_id
                     baggage.set_baggage(f"execution.{traceparent}", session_id)
-                http_kwargs["headers"] = headers
-            return await original_send_message(self, request, http_kwargs=http_kwargs)
 
-        from a2a.client import A2AClient
+                metadata["observe"] = observe_meta
+
+                # Write back metadata (pydantic models are mutable by default in v2)
+                try:
+                    request.params.metadata = metadata
+                except Exception:
+                    # Fallback
+                    request = request.model_copy(
+                        update={
+                            "params": request.params.model_copy(
+                                update={"metadata": metadata}
+                            )
+                        }
+                    )
+
+            # Call through without transport-specific kwargs
+            return await original_send_message(self, request, *args, **kwargs)
 
         A2AClient.send_message = instrumented_send_message
 
+        # Instrument server handler
         from a2a.server.request_handlers import DefaultRequestHandler
 
         original_server_on_message_send = DefaultRequestHandler.on_message_send
 
         @functools.wraps(original_server_on_message_send)
-        async def instrumented_execute(self, params, context):
-            # Extract headers from context (assume context.request.headers)
-
-            traceparent = context.state.get("headers", {}).get("traceparent")
-            session_id = context.state.get("headers", {}).get("session_id")
-            carrier = {
-                k.lower(): v
-                for k, v in context.state.get("headers", {}).items()
-                if k.lower() in ["traceparent", "baggage"]
-            }
-            if carrier and traceparent:
+        async def instrumented_on_message_send(self, params, context):
+            # Read context from A2A message metadata (transport-agnostic)
+            try:
+                metadata = getattr(params, "metadata", {}) or {}
+            except Exception:
+                metadata = {}
+
+            carrier = {}
+            observe_meta = metadata.get("observe", {}) or {}
+            # Accept keys we inject
+            for k in ("traceparent", "baggage", "session_id"):
+                if k in observe_meta:
+                    carrier[k] = observe_meta[k]
+
+            token = None
+            if carrier.get("traceparent"):
+                # Extract and attach parent context
                 ctx = TraceContextTextMapPropagator().extract(carrier=carrier)
                 ctx = W3CBaggagePropagator().extract(carrier=carrier, context=ctx)
+                try:
+                    from opentelemetry import context as otel_ctx
+
+                    token = otel_ctx.attach(ctx)
+                except Exception:
+                    token = None
+
+                session_id = observe_meta.get("session_id")
                 if session_id and session_id != "None":
-                    set_session_id(session_id, traceparent=traceparent)
-                    kv_store.set(f"execution.{traceparent}", session_id)
-            return await original_server_on_message_send(self, params, context)
+                    set_session_id(session_id, traceparent=carrier.get("traceparent"))
+                    kv_store.set(f"execution.{carrier.get('traceparent')}", session_id)
 
-        from a2a.server.request_handlers import DefaultRequestHandler
+            try:
+                return await original_server_on_message_send(self, params, context)
+            finally:
+                if token is not None:
+                    try:
+                        otel_ctx.detach(token)
+                    except Exception:
+                        pass
+
+        DefaultRequestHandler.on_message_send = instrumented_on_message_send
+
+        # from a2a.client import A2AClient
+
+        # A2AClient.send_message = instrumented_send_message
+
+        # from a2a.server.request_handlers import DefaultRequestHandler
 
-        DefaultRequestHandler.on_message_send = instrumented_execute
+        # original_server_on_message_send = DefaultRequestHandler.on_message_send
 
     def _uninstrument(self, **kwargs):
         import importlib
@@ -103,7 +156,7 @@ class A2AInstrumentor(BaseInstrumentor):
 
         A2AClient.send_message = A2AClient.send_message.__wrapped__
 
-        # Uninstrument `execute`
+        # Uninstrument server handler
         from a2a.server.request_handlers import DefaultRequestHandler
 
         DefaultRequestHandler.on_message_send = (

ioa_observe/sdk/instrumentations/mcp.py

@@ -0,0 +1,494 @@
+# Copyright AGNTCY Contributors (https://github.com/agntcy)
+# SPDX-License-Identifier: Apache-2.0
+
+from contextlib import asynccontextmanager
+from dataclasses import dataclass
+from typing import Any, AsyncGenerator, Callable, Collection, Tuple, cast, Union
+import json
+import logging
+import traceback
+import re
+from http import HTTPStatus
+
+from opentelemetry import context, propagate
+from opentelemetry.instrumentation.instrumentor import BaseInstrumentor
+from opentelemetry.instrumentation.utils import unwrap
+from opentelemetry.trace import get_tracer, Tracer
+from wrapt import ObjectProxy, register_post_import_hook, wrap_function_wrapper
+from opentelemetry.trace.status import Status, StatusCode
+from opentelemetry.trace.propagation.tracecontext import TraceContextTextMapPropagator
+from opentelemetry.semconv.attributes.error_attributes import ERROR_TYPE
+
+from ..utils.const import (
+    MCP_REQUEST_ID,
+    MCP_METHOD_NAME,
+    MCP_REQUEST_ARGUMENT,
+    MCP_RESPONSE_VALUE,
+    OBSERVE_ENTITY_OUTPUT,
+    OBSERVE_ENTITY_INPUT,
+)
+from ..version import __version__
+
+_instruments = ("mcp >= 1.6.0",)
+
+
+class Config:
+    exception_logger = None
+
+
+def dont_throw(func):
+    """
+    A decorator that wraps the passed in function and logs exceptions instead of throwing them.
+
+    @param func: The function to wrap
+    @return: The wrapper function
+    """
+    # Obtain a logger specific to the function's module
+    logger = logging.getLogger(func.__module__)
+
+    def wrapper(*args, **kwargs):
+        try:
+            return func(*args, **kwargs)
+        except Exception as e:
+            logger.debug(
+                "failed to trace in %s, error: %s",
+                func.__name__,
+                traceback.format_exc(),
+            )
+            if Config.exception_logger:
+                Config.exception_logger(e)
+
+    return wrapper
+
+
+class McpInstrumentor(BaseInstrumentor):
+    def instrumentation_dependencies(self) -> Collection[str]:
+        return _instruments
+
+    def _instrument(self, **kwargs):
+        tracer_provider = kwargs.get("tracer_provider")
+        tracer = get_tracer(__name__, __version__, tracer_provider)
+
+        register_post_import_hook(
+            lambda _: wrap_function_wrapper(
+                "mcp.client.sse", "sse_client", self._transport_wrapper(tracer)
+            ),
+            "mcp.client.sse",
+        )
+        register_post_import_hook(
+            lambda _: wrap_function_wrapper(
+                "mcp.server.sse",
+                "SseServerTransport.connect_sse",
+                self._transport_wrapper(tracer),
+            ),
+            "mcp.server.sse",
+        )
+        register_post_import_hook(
+            lambda _: wrap_function_wrapper(
+                "mcp.client.stdio", "stdio_client", self._transport_wrapper(tracer)
+            ),
+            "mcp.client.stdio",
+        )
+        register_post_import_hook(
+            lambda _: wrap_function_wrapper(
+                "mcp.server.stdio", "stdio_server", self._transport_wrapper(tracer)
+            ),
+            "mcp.server.stdio",
+        )
+        register_post_import_hook(
+            lambda _: wrap_function_wrapper(
+                "mcp.server.session",
+                "ServerSession.__init__",
+                self._base_session_init_wrapper(tracer),
+            ),
+            "mcp.server.session",
+        )
+        register_post_import_hook(
+            lambda _: wrap_function_wrapper(
+                "mcp.client.streamable_http",
+                "streamablehttp_client",
+                self._transport_wrapper(tracer),
+            ),
+            "mcp.client.streamable_http",
+        )
+        register_post_import_hook(
+            lambda _: wrap_function_wrapper(
+                "mcp.server.streamable_http",
+                "StreamableHTTPServerTransport.connect",
+                self._transport_wrapper(tracer),
+            ),
+            "mcp.server.streamable_http",
+        )
+        wrap_function_wrapper(
+            "mcp.shared.session",
+            "BaseSession.send_request",
+            self.patch_mcp_client(tracer),
+        )
+
+    def _uninstrument(self, **kwargs):
+        unwrap("mcp.client.stdio", "stdio_client")
+        unwrap("mcp.server.stdio", "stdio_server")
+
+    def _transport_wrapper(self, tracer):
+        @asynccontextmanager
+        async def traced_method(
+            wrapped: Callable[..., Any], instance: Any, args: Any, kwargs: Any
+        ) -> AsyncGenerator[
+            Union[
+                Tuple[InstrumentedStreamReader, InstrumentedStreamWriter],
+                Tuple[InstrumentedStreamReader, InstrumentedStreamWriter, Any],
+            ],
+            None,
+        ]:
+            async with wrapped(*args, **kwargs) as result:
+                try:
+                    read_stream, write_stream = result
+                    yield (
+                        InstrumentedStreamReader(read_stream, tracer),
+                        InstrumentedStreamWriter(write_stream, tracer),
+                    )
+                except ValueError:
+                    try:
+                        read_stream, write_stream, get_session_id_callback = result
+                        yield (
+                            InstrumentedStreamReader(read_stream, tracer),
+                            InstrumentedStreamWriter(write_stream, tracer),
+                            get_session_id_callback,
+                        )
+                    except Exception as e:
+                        logging.warning(
+                            f"mcp instrumentation _transport_wrapper exception: {e}"
+                        )
+                        yield result
+                except Exception as e:
+                    logging.warning(
+                        f"mcp instrumentation transport_wrapper exception: {e}"
+                    )
+                    yield result
+
+        return traced_method
+
+    def _base_session_init_wrapper(self, tracer):
+        def traced_method(
+            wrapped: Callable[..., None], instance: Any, args: Any, kwargs: Any
+        ) -> None:
+            wrapped(*args, **kwargs)
+            reader = getattr(instance, "_incoming_message_stream_reader", None)
+            writer = getattr(instance, "_incoming_message_stream_writer", None)
+            if reader and writer:
+                setattr(
+                    instance,
+                    "_incoming_message_stream_reader",
+                    ContextAttachingStreamReader(reader, tracer),
+                )
+                setattr(
+                    instance,
+                    "_incoming_message_stream_writer",
+                    ContextSavingStreamWriter(writer, tracer),
+                )
+
+        return traced_method
+
+    def patch_mcp_client(self, tracer: Tracer):
+        @dont_throw
+        async def traced_method(wrapped, instance, args, kwargs):
+            meta = None
+            method = None
+            params = None
+            if len(args) > 0 and hasattr(args[0].root, "method"):
+                method = args[0].root.method
+            if len(args) > 0 and hasattr(args[0].root, "params"):
+                params = args[0].root.params
+            if params:
+                if hasattr(args[0].root.params, "meta"):
+                    meta = args[0].root.params.meta
+
+            with tracer.start_as_current_span(f"{method}.mcp") as span:
+                span.set_attribute(OBSERVE_ENTITY_INPUT, f"{serialize(args[0])}")
+                from ioa_observe.sdk.client import kv_store
+                from ioa_observe.sdk.tracing import get_current_traceparent
+
+                traceparent = get_current_traceparent()
+                session_id = None
+                if traceparent:
+                    session_id = kv_store.get(f"execution.{traceparent}")
+                    if session_id:
+                        kv_store.set(f"execution.{traceparent}", session_id)
+
+                        meta = meta or {}
+                        if isinstance(meta, dict):
+                            meta["session.id"] = session_id
+                            meta["traceparent"] = traceparent
+                        else:
+                            # If meta is an object, convert it to a dict
+                            meta = {
+                                "session.id": session_id,
+                                "traceparent": traceparent,
+                            }
+
+                if meta and len(args) > 0:
+                    carrier = {}
+                    TraceContextTextMapPropagator().inject(carrier)
+
+                    args[0].root.params.meta = meta
+
+                try:
+                    result = await wrapped(*args, **kwargs)
+                    span.set_attribute(
+                        OBSERVE_ENTITY_OUTPUT,
+                        serialize(result),
+                    )
+                    if hasattr(result, "isError") and result.isError:
+                        if len(result.content) > 0:
+                            span.set_status(
+                                Status(StatusCode.ERROR, f"{result.content[0].text}")
+                            )
+                            error_type = get_error_type(result.content[0].text)
+                            if error_type is not None:
+                                span.set_attribute(ERROR_TYPE, error_type)
+                    else:
+                        span.set_status(Status(StatusCode.OK))
+                    return result
+                except Exception as e:
+                    span.set_attribute(ERROR_TYPE, type(e).__name__)
+                    span.record_exception(e)
+                    span.set_status(Status(StatusCode.ERROR, str(e)))
+                    raise
+
+        return traced_method
+
+
+def get_error_type(error_message):
+    if not isinstance(error_message, str):
+        return None
+    match = re.search(r"\b(4\d{2}|5\d{2})\b", error_message)
+    if match:
+        num = int(match.group())
+        if 400 <= num <= 599:
+            return HTTPStatus(num).name
+        else:
+            return None
+    else:
+        return None
+
+
+def serialize(request, depth=0, max_depth=4):
+    """Serialize input args to MCP server into JSON.
+    The function accepts input object and converts into JSON
+    keeping depth in mind to prevent creating large nested JSON"""
+    if depth > max_depth:
+        return {}
+    depth += 1
+
+    def is_serializable(request):
+        try:
+            json.dumps(request)
+            return True
+        except Exception:
+            return False
+
+    if is_serializable(request):
+        return json.dumps(request)
+    else:
+        result = {}
+        try:
+            if hasattr(request, "model_dump_json"):
+                return request.model_dump_json()
+            if hasattr(request, "__dict__"):
+                for attrib in request.__dict__:
+                    if not attrib.startswith("_"):
+                        if type(request.__dict__[attrib]) in [
+                            bool,
+                            str,
+                            int,
+                            float,
+                            type(None),
+                        ]:
+                            result[str(attrib)] = request.__dict__[attrib]
+                        else:
+                            result[str(attrib)] = serialize(
+                                request.__dict__[attrib], depth
+                            )
+        except Exception:
+            pass
+        return json.dumps(result)
+
+
+class InstrumentedStreamReader(ObjectProxy):  # type: ignore
+    def __init__(self, wrapped, tracer):
+        super().__init__(wrapped)
+        self._tracer = tracer
+
+    async def __aenter__(self) -> Any:
+        return await self.__wrapped__.__aenter__()
+
+    async def __aexit__(self, exc_type: Any, exc_value: Any, traceback: Any) -> Any:
+        return await self.__wrapped__.__aexit__(exc_type, exc_value, traceback)
+
+    @dont_throw
+    async def __aiter__(self) -> AsyncGenerator[Any, None]:
+        from mcp.types import JSONRPCMessage, JSONRPCRequest
+        from mcp.shared.message import SessionMessage
+
+        async for item in self.__wrapped__:
+            if isinstance(item, SessionMessage):
+                request = cast(JSONRPCMessage, item.message).root
+            elif type(item) is JSONRPCMessage:
+                request = cast(JSONRPCMessage, item).root
+            else:
+                yield item
+                continue
+
+            if not isinstance(request, JSONRPCRequest):
+                yield item
+                continue
+
+            if request.params:
+                # Check both _meta and meta fields
+                meta = request.params.get("_meta") or getattr(
+                    request.params, "meta", None
+                )
+
+                if meta:
+                    if isinstance(meta, dict):
+                        session_id = meta.get("session.id")
+                        traceparent = meta.get("traceparent")
+                        carrier = meta
+                    else:
+                        session_id = getattr(meta, "session.id", None)
+                        traceparent = getattr(meta, "traceparent", None)
+                        # Convert object to dict for propagate.extract
+                        carrier = {}
+                        if session_id:
+                            carrier["session.id"] = session_id
+
+                    if carrier and traceparent:
+                        ctx = propagate.extract(carrier)
+
+                        # Add session_id extraction and storage like in a2a.py
+                        if session_id and session_id != "None":
+                            from ioa_observe.sdk.client import kv_store
+                            from ioa_observe.sdk.tracing import set_session_id
+
+                            set_session_id(session_id, traceparent=traceparent)
+                            kv_store.set(f"execution.{traceparent}", session_id)
+
+                        restore = context.attach(ctx)
+                        try:
+                            yield item
+                            continue
+                        finally:
+                            context.detach(restore)
+            yield item
+
+
+class InstrumentedStreamWriter(ObjectProxy):  # type: ignore
+    def __init__(self, wrapped, tracer):
+        super().__init__(wrapped)
+        self._tracer = tracer
+
+    async def __aenter__(self) -> Any:
+        return await self.__wrapped__.__aenter__()
+
+    async def __aexit__(self, exc_type: Any, exc_value: Any, traceback: Any) -> Any:
+        return await self.__wrapped__.__aexit__(exc_type, exc_value, traceback)
+
+    @dont_throw
+    async def send(self, item: Any) -> Any:
+        from mcp.types import JSONRPCMessage, JSONRPCRequest
+        from mcp.shared.message import SessionMessage
+
+        if isinstance(item, SessionMessage):
+            request = cast(JSONRPCMessage, item.message).root
+        elif type(item) is JSONRPCMessage:
+            request = cast(JSONRPCMessage, item).root
+        else:
+            return
+
+        with self._tracer.start_as_current_span("ResponseStreamWriter") as span:
+            if hasattr(request, "result"):
+                span.set_attribute(MCP_RESPONSE_VALUE, f"{serialize(request.result)}")
+                if "isError" in request.result:
+                    if request.result["isError"] is True:
+                        span.set_status(
+                            Status(
+                                StatusCode.ERROR,
+                                f"{request.result['content'][0]['text']}",
+                            )
+                        )
+                        error_type = get_error_type(
+                            request.result["content"][0]["text"]
+                        )
+                        if error_type is not None:
+                            span.set_attribute(ERROR_TYPE, error_type)
+            if hasattr(request, "id"):
+                span.set_attribute(MCP_REQUEST_ID, f"{request.id}")
+
+            if not isinstance(request, JSONRPCRequest):
+                return await self.__wrapped__.send(item)
+            meta = None
+            if not request.params:
+                request.params = {}
+            meta = request.params.setdefault("_meta", {})
+
+            propagate.get_global_textmap().inject(meta)
+            return await self.__wrapped__.send(item)
+
+
+@dataclass(slots=True, frozen=True)
+class ItemWithContext:
+    item: Any
+    ctx: context.Context
+
+
+class ContextSavingStreamWriter(ObjectProxy):  # type: ignore
+    def __init__(self, wrapped, tracer):
+        super().__init__(wrapped)
+        self._tracer = tracer
+
+    async def __aenter__(self) -> Any:
+        return await self.__wrapped__.__aenter__()
+
+    async def __aexit__(self, exc_type: Any, exc_value: Any, traceback: Any) -> Any:
+        return await self.__wrapped__.__aexit__(exc_type, exc_value, traceback)
+
+    @dont_throw
+    async def send(self, item: Any) -> Any:
+        with self._tracer.start_as_current_span("RequestStreamWriter") as span:
+            if hasattr(item, "request_id"):
+                span.set_attribute(MCP_REQUEST_ID, f"{item.request_id}")
+            if hasattr(item, "request"):
+                if hasattr(item.request, "root"):
+                    if hasattr(item.request.root, "method"):
+                        span.set_attribute(
+                            MCP_METHOD_NAME,
+                            f"{item.request.root.method}",
+                        )
+                    if hasattr(item.request.root, "params"):
+                        span.set_attribute(
+                            MCP_REQUEST_ARGUMENT,
+                            f"{serialize(item.request.root.params)}",
+                        )
+            ctx = context.get_current()
+            return await self.__wrapped__.send(ItemWithContext(item, ctx))
+
+
+class ContextAttachingStreamReader(ObjectProxy):  # type: ignore
+    def __init__(self, wrapped, tracer):
+        super().__init__(wrapped)
+        self._tracer = tracer
+
+    async def __aenter__(self) -> Any:
+        return await self.__wrapped__.__aenter__()
+
+    async def __aexit__(self, exc_type: Any, exc_value: Any, traceback: Any) -> Any:
+        return await self.__wrapped__.__aexit__(exc_type, exc_value, traceback)
+
+    async def __aiter__(self) -> AsyncGenerator[Any, None]:
+        async for item in self.__wrapped__:
+            item_with_context = cast(ItemWithContext, item)
+            restore = context.attach(item_with_context.ctx)
+            try:
+                yield item_with_context.item
+            finally:
+                context.detach(restore)

ioa_observe/sdk/tracing/tracing.py

@@ -38,6 +38,10 @@ from opentelemetry.semconv_ai import SpanAttributes
 from ioa_observe.sdk import Telemetry
 from ioa_observe.sdk.instruments import Instruments
 from ioa_observe.sdk.tracing.content_allow_list import ContentAllowList
+from ioa_observe.sdk.tracing.transform_span import (
+    transform_json_object_configurable,
+    validate_transformer_rules,
+)
 from ioa_observe.sdk.utils import is_notebook
 from ioa_observe.sdk.client import kv_store
 
@@ -106,8 +110,8 @@ def determine_reliability_score(span):
 class TracerWrapper(object):
     resource_attributes: dict = {}
     enable_content_tracing: bool = True
-    endpoint: str = (None,)
-    app_name: str = (None,)
+    endpoint: str = None
+    app_name: str = None
     headers: Dict[str, str] = {}
     __tracer_provider: TracerProvider = None
     __disabled: bool = False
@@ -129,7 +133,10 @@ class TracerWrapper(object):
                 return obj
 
             obj.__image_uploader = image_uploader
-            obj._agent_execution_counts = {}  # {(agent_name): [success_count, total_count]}
+            # {(agent_name): [success_count, total_count]}
+            obj._agent_execution_counts = {}
+            # Track spans that have been processed to avoid duplicates
+            obj._processed_spans = set()
             TracerWrapper.app_name = TracerWrapper.resource_attributes.get(
                 "service.name", "observe"
             )
@@ -139,6 +146,7 @@ class TracerWrapper(object):
                 Telemetry().capture("tracer:init", {"processor": "custom"})
                 obj.__spans_processor: SpanProcessor = processor
                 obj.__spans_processor_original_on_start = processor.on_start
+                obj.__spans_processor_original_on_end = processor.on_end
             else:
                 if exporter:
                     Telemetry().capture(
@@ -175,9 +183,10 @@ class TracerWrapper(object):
                         schedule_delay_millis=5000,
                     )
                 obj.__spans_processor_original_on_start = None
+                obj.__spans_processor_original_on_end = obj.__spans_processor.on_end
 
             obj.__spans_processor.on_start = obj._span_processor_on_start
-            # obj.__spans_processor.on_end = obj.span_processor_on_ending
+            obj.__spans_processor.on_end = obj.span_processor_on_ending
             obj.__tracer_provider.add_span_processor(obj.__spans_processor)
             # Custom metric, for example
             meter = get_meter("observe")
@@ -338,14 +347,114 @@ class TracerWrapper(object):
         self.number_active_agents.add(count, attributes=span.attributes)
 
     def span_processor_on_ending(self, span):
+        # Check if this span has already been processed to avoid duplicate processing
+        # Added for avoid duplicate on_ending with manual triggers
+        # from decorators (@tool, @workflow) in base.py
+        span_id = span.context.span_id
+        if span_id in self._processed_spans:
+            # This span was already processed, skip to avoid duplicates
+            return
+
+        # Mark this span as processed
+        self._processed_spans.add(span_id)
+
         determine_reliability_score(span)
         start_time = span.attributes.get("ioa_start_time")
-        # publish span to the exporter
+
+        # Apply transformations if enabled
+        apply_transform = get_value("apply_transform")
+        if apply_transform:
+            transformer_rules = get_value("transformer_rules")
+            if transformer_rules:
+                try:
+                    # Convert span to dict for transformation
+                    span_dict = self._span_to_dict(span)
+                    # Apply transformation
+                    transformed_span_dict = transform_json_object_configurable(
+                        span_dict, transformer_rules
+                    )
+                    # Update span with transformed data
+                    self._update_span_from_dict(span, transformed_span_dict)
+                except Exception as e:
+                    logging.error(f"Error applying span transformation: {e}")
 
         if start_time is not None:
             latency = (time.time() - start_time) * 1000
             self.response_latency_histogram.record(latency, attributes=span.attributes)
 
+        # Call original on_end method if it exists
+        if (
+            hasattr(self, "_TracerWrapper__spans_processor_original_on_end")
+            and self.__spans_processor_original_on_end
+        ):
+            self.__spans_processor_original_on_end(span)
+
+    def _span_to_dict(self, span):
+        """Convert span to dictionary for transformation."""
+        span_dict = {
+            "name": span.name,
+            "attributes": dict(span.attributes) if span.attributes else {},
+            "status": {
+                "status_code": span.status.status_code.name
+                if span.status and span.status.status_code
+                else None,
+                "description": span.status.description if span.status else None,
+            },
+        }
+        return span_dict
+
+    def _update_span_from_dict(self, span, span_dict):
+        """Update span with transformed data."""
+        # Update span name if it was transformed
+        if "name" in span_dict and span_dict["name"] != span.name:
+            # Directly modify the internal name attribute
+            if hasattr(span, "_name"):
+                span._name = span_dict["name"]
+
+        # Update attributes if they were transformed
+        if "attributes" in span_dict:
+            # Try multiple approaches to update span attributes
+            updated = False
+
+            # Method 1: Try using set_attribute if available and mutable
+            if (
+                hasattr(span, "set_attribute")
+                and hasattr(span, "_ended")
+                and not span._ended
+            ):
+                try:
+                    # Clear existing attributes by setting them to None
+                    if hasattr(span, "_attributes"):
+                        keys_to_remove = list(span._attributes.keys())
+                        for key in keys_to_remove:
+                            span.set_attribute(key, None)
+
+                    # Set new attributes
+                    for key, value in span_dict["attributes"].items():
+                        span.set_attribute(key, value)
+                    updated = True
+                except (AttributeError, TypeError):
+                    pass
+
+            # Method 2: Direct attribute manipulation
+            if not updated:
+                try:
+                    if hasattr(span, "_attributes"):
+                        span._attributes.clear()
+                        span._attributes.update(span_dict["attributes"])
+                        updated = True
+                    elif hasattr(span, "attributes") and hasattr(
+                        span.attributes, "clear"
+                    ):
+                        span.attributes.clear()
+                        span.attributes.update(span_dict["attributes"])
+                        updated = True
+                except (AttributeError, TypeError):
+                    pass
+
+            if not updated:
+                logging.warning("Cannot modify span attributes - span may be finalized")
+
     @staticmethod
     def set_static_params(
         resource_attributes: dict,
@@ -423,14 +532,101 @@ def set_workflow_name(workflow_name: str) -> None:
     attach(set_value("workflow_name", workflow_name))
 
 
-def session_start():
+def _parse_boolean_env(env_value: str) -> bool:
+    """
+    Parse boolean value from environment variable string.
+
+    Args:
+        env_value (str): Environment variable value to parse
+
+    Returns:
+        bool: Parsed boolean value
+
+    Accepts: "0", "1", "true", "false", "True", "False"
+    """
+    if env_value.lower() in ("true", "1"):
+        return True
+    elif env_value.lower() in ("false", "0"):
+        return False
+    else:
+        raise ValueError(f"Invalid boolean value: {env_value}")
+
+
+def session_start(apply_transform: bool = False):
     """
     Can be used as a context manager or a normal function.
     As a context manager, yields session metadata.
     As a normal function, just sets up the session.
+
+    Args:
+        apply_transform (bool): If True, enables span transformation based on
+                               rules loaded from SPAN_TRANSFORMER_RULES_FILE env.
+                               Can be overridden by
+                               SPAN_TRANSFORMER_RULES_ENABLED env var.
     """
-    session_id = TracerWrapper.app_name + "_" + str(uuid.uuid4())
+    session_id = (TracerWrapper.app_name or "observe") + "_" + str(uuid.uuid4())
     set_session_id(session_id)
+
+    # Check if environment variable overrides the apply_transform parameter
+    transformer_enabled_env = os.getenv("SPAN_TRANSFORMER_RULES_ENABLED")
+    if transformer_enabled_env:
+        try:
+            apply_transform = _parse_boolean_env(transformer_enabled_env)
+        except ValueError as e:
+            logging.error(
+                "Invalid SPAN_TRANSFORMER_RULES_ENABLED value: "
+                f"{e}. Using parameter value: {apply_transform}"
+            )
+
+    # Handle transformation flag
+    if apply_transform:
+        transformer_rules_file = os.getenv("SPAN_TRANSFORMER_RULES_FILE")
+        if not transformer_rules_file:
+            logging.error(
+                "SPAN_TRANSFORMER_RULES_FILE environment variable "
+                "not set. Disabling transformation."
+            )
+            apply_transform = False
+        elif not os.path.exists(transformer_rules_file):
+            logging.error(
+                "Transformer rules file not found: "
+                f"{transformer_rules_file}. Disabling "
+                "transformation."
+            )
+            apply_transform = False
+        else:
+            try:
+                with open(transformer_rules_file, "r") as f:
+                    transformer_rules = json.load(f)
+                # Validate structure and rules
+                validate_transformer_rules(transformer_rules)
+                attach(set_value("apply_transform", True))
+                attach(set_value("transformer_rules", transformer_rules))
+            except json.JSONDecodeError as e:
+                logging.error(
+                    "Failed to load transformer rules from "
+                    f"{transformer_rules_file}: {e}. Disabling "
+                    "transformation."
+                )
+                apply_transform = False
+            except ValueError:
+                logging.error(
+                    "Invalid transformer rules structure. "
+                    "Expected 'RULES' section. "
+                    "Disabling transformation."
+                )
+                apply_transform = False
+            except (json.JSONDecodeError, Exception) as e:
+                logging.error(
+                    "Failed to load transformer rules from "
+                    f"{transformer_rules_file}: {e}. "
+                    "Disabling transformation."
+                )
+                apply_transform = False
+
+    if not apply_transform:
+        attach(set_value("apply_transform", False))
+
     metadata = {
         "executionID": get_value("session.id") or session_id,
         "traceparentID": get_current_traceparent(),
@@ -581,14 +777,23 @@ def is_llm_span(span) -> bool:
 
 
 def init_spans_exporter(api_endpoint: str, headers: Dict[str, str]) -> SpanExporter:
-    if "http" in api_endpoint.lower() or "https" in api_endpoint.lower():
+    if api_endpoint and (
+        "http" in api_endpoint.lower() or "https" in api_endpoint.lower()
+    ):
         return HTTPExporter(
             endpoint=f"{api_endpoint}/v1/traces",
             headers=headers,
             compression=Compression.Gzip,
         )
-    else:
+    elif api_endpoint:
         return GRPCExporter(endpoint=f"{api_endpoint}", headers=headers)
+    else:
+        # Default to HTTP exporter with localhost when endpoint is None
+        return HTTPExporter(
+            endpoint="http://localhost:4318/v1/traces",
+            headers=headers,
+            compression=Compression.Gzip,
+        )
 
 
 def init_tracer_provider(resource: Resource) -> TracerProvider:

ioa_observe/sdk/tracing/transform_span.py

@@ -0,0 +1,210 @@
+# Copyright AGNTCY Contributors (https://github.com/agntcy)
+# SPDX-License-Identifier: Apache-2.0
+
+
+def validate_transformer_rules(config):
+    """
+    Validates the transformer rules configuration.
+
+    Args:
+        config (dict): The configuration dictionary to validate.
+
+    Raises:
+        ValueError: If the configuration is invalid.
+
+    Validation rules:
+    - Must have RULES section containing a list of transformation rules
+    - Each rule must have a 'path' field (list of strings)
+    - Path length = 1: Global transformation (e.g., ["old_key"])
+    - Path length > 1: Path-specific transformation
+      (e.g., ["attributes", "nested_key"])
+    - action_conflict must be one of: SKIP, REPLACE, DELETE
+    - DELETE action should not have a 'rename' field
+    """
+    if not isinstance(config, dict):
+        raise ValueError("Configuration must be a dictionary")
+
+    if "RULES" not in config:
+        raise ValueError("Configuration must contain 'RULES' section")
+
+    rules_section = config.get("RULES", [])
+    if not isinstance(rules_section, list):
+        raise ValueError("RULES section must be a list")
+
+    for i, rule in enumerate(rules_section):
+        if not isinstance(rule, dict):
+            raise ValueError(f"Rule {i} must be a dictionary")
+
+        # Check required fields
+        if "path" not in rule:
+            raise ValueError(f"Rule {i} must have 'path' field")
+
+        if not isinstance(rule["path"], list):
+            raise ValueError(f"Rule {i} 'path' must be a list")
+
+        if not rule["path"]:
+            raise ValueError(f"Rule {i} 'path' cannot be empty")
+
+        # Check action_conflict
+        action_conflict = rule.get("action_conflict", "REPLACE")
+        if action_conflict not in ["SKIP", "REPLACE", "DELETE"]:
+            raise ValueError(
+                f"Rule {i} action_conflict must be one of: SKIP, REPLACE, DELETE"
+            )
+
+        # Check rename field for non-DELETE actions
+        if action_conflict != "DELETE" and "rename" not in rule:
+            raise ValueError(
+                f"Rule {i} with {action_conflict} action must have 'rename' field"
+            )
+
+        # Check rename field for DELETE action
+        if action_conflict == "DELETE" and "rename" in rule:
+            raise ValueError(
+                f"Rule {i} with DELETE action should not have 'rename' field"
+            )
+
+
+def transform_json_object_configurable(data, config, current_path=()):
+    """
+    Recursively transforms a JSON object (dict or list) based on a unified
+    configuration that contains transformation rules for both global and
+    path-specific key renames, along with conflict resolution strategies.
+
+    Args:
+        data (dict or list or primitive): The JSON object or part of it
+                                          to transform.
+        config (dict): A dictionary containing transformation rules:
+                       {
+                           "RULES": [
+                               {
+                                   "path": ["old_key"],
+                                   "rename": "new_key",
+                                   "action_conflict": "SKIP"|"REPLACE"|"DELETE"
+                               },
+                               {
+                                   "path": ["attributes",
+                                           "traceloop.span.kind"],
+                                   "rename": "ioa_observe.span_kind",
+                                   "action_conflict": "REPLACE"
+                               },
+                               ...
+                           ]
+                       }
+        current_path (tuple): The current path (sequence of keys) from the
+                              root to the current data element.
+                              Used for path-specific lookups.
+
+    Returns:
+        dict or list or primitive: The transformed JSON object.
+    """
+    if isinstance(data, dict):
+        new_data = {}
+        for key, value in data.items():
+            full_key_path = current_path + (key,)
+
+            # Recursively transform the value first
+            transformed_value = transform_json_object_configurable(
+                value, config, full_key_path
+            )
+
+            # Default to no rename and 'REPLACE' conflict strategy
+            target_new_key = key
+            action_on_conflict = "REPLACE"
+            rule_applied = False
+
+            # Check for matching rules based on path
+            rules = config.get("RULES", [])
+            for rule in rules:
+                rule_path = tuple(rule["path"])
+
+                # Check if this rule applies to the current path
+                if len(rule_path) == 1:
+                    # Global rule: applies if the key matches
+                    if rule_path[0] == key:
+                        action_on_conflict = rule.get("action_conflict", "REPLACE")
+
+                        if action_on_conflict == "DELETE":
+                            # DELETE action: skip adding this key entirely
+                            rule_applied = True
+                            break
+                        elif "rename" in rule:
+                            target_new_key = rule["rename"]
+                            rule_applied = True
+                            break
+                else:
+                    # Path-specific rule: applies if full path matches
+                    if full_key_path == rule_path:
+                        action_on_conflict = rule.get("action_conflict", "REPLACE")
+
+                        if action_on_conflict == "DELETE":
+                            # DELETE action: skip adding this key entirely
+                            rule_applied = True
+                            break
+                        elif "rename" in rule:
+                            target_new_key = rule["rename"]
+                            rule_applied = True
+                            break
+
+            # Skip to next iteration if DELETE action was applied
+            if rule_applied and action_on_conflict == "DELETE":
+                continue
+
+            # Now, decide which key to use in new_data based on rules and
+            # conflict strategy
+            if rule_applied and target_new_key != key:
+                # A rename was proposed
+                if action_on_conflict == "SKIP" and (
+                    target_new_key in data or target_new_key in new_data
+                ):
+                    # If target key already exists in original data OR new_data
+                    # AND action is SKIP, keep the original key and its
+                    # transformed value. The rename is effectively "skipped".
+                    new_data[key] = transformed_value
+                else:
+                    # If action is REPLACE, or target key doesn't exist,
+                    # then perform the rename.
+                    # This will either add a new key or overwrite an
+                    # existing one.
+                    new_data[target_new_key] = transformed_value
+            else:
+                # No rule applied or DELETE handled above
+                new_data[key] = transformed_value
+
+        return new_data
+    elif isinstance(data, list):
+        new_list = []
+        for item in data:
+            # For list items, the path context usually doesn't change
+            # for the elements themselves
+            new_list.append(
+                transform_json_object_configurable(item, config, current_path)
+            )
+        return new_list
+    else:
+        # Base case: primitive types (str, int, float, bool, None)
+        # are returned as is
+        return data
+
+
+def transform_list_of_json_objects_configurable(json_objects_list, config):
+    """
+    Transforms a list of JSON objects by applying key replacements based on
+    the provided unified configuration.
+
+    Args:
+        json_objects_list (list): A list of Python dictionary objects
+                                  (parsed JSON).
+        config (dict): The unified configuration dictionary for
+                       transformations.
+
+    Returns:
+        list: A new list containing the transformed JSON objects.
+    """
+    if not isinstance(json_objects_list, list):
+        raise TypeError("Input must be a list of JSON objects.")
+
+    transformed_list = [
+        transform_json_object_configurable(obj, config) for obj in json_objects_list
+    ]
+    return transformed_list

ioa_observe/sdk/utils/const.py

@@ -21,6 +21,13 @@ OBSERVE_PROMPT_VERSION_HASH = "ioa_observe.prompt.version_hash"
 OBSERVE_PROMPT_TEMPLATE = "ioa_observe.prompt.template"
 OBSERVE_PROMPT_TEMPLATE_VARIABLES = "ioa_observe.prompt.template_variables"
 
+# MCP
+MCP_METHOD_NAME = "mcp.method.name"
+MCP_REQUEST_ARGUMENT = "mcp.request.argument"
+MCP_REQUEST_ID = "mcp.request.id"
+MCP_SESSION_INIT_OPTIONS = "mcp.session.init_options"
+MCP_RESPONSE_VALUE = "mcp.response.value"
+
 
 class ObserveSpanKindValues(Enum):
     WORKFLOW = "workflow"

{ioa_observe_sdk-1.0.15.dist-info → ioa_observe_sdk-1.0.16.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ioa-observe-sdk
-Version: 1.0.15
+Version: 1.0.16
 Summary: IOA Observability SDK
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
@@ -82,6 +82,8 @@ This schema is designed to provide comprehensive observability for Multi-Agent S
 
 Link: [AGNTCY Observability Schema](https://github.com/agntcy/observe/blob/main/schema/)
 
+An option is made available for transforming spans attributes exported by using options via env variables (SPAN_TRANSFORMER_RULES_ENABLED, SPAN_TRANSFORMER_RULES_FILE). Please read [transform](./sdk/tracing/transform_span.py).
+
 ## Dev
 
 Any Opentelemetry compatible backend can be used, but for this guide, we will use ClickhouseDB as the backend database.

{ioa_observe_sdk-1.0.15.dist-info → ioa_observe_sdk-1.0.16.dist-info}/RECORD

@@ -1,20 +1,21 @@
 ioa_observe/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-ioa_observe/sdk/__init__.py,sha256=h_dALthPo9HpUwNyEp7p9kTYlkaghx9ZY3b-YzVV2Vs,8824
+ioa_observe/sdk/__init__.py,sha256=GgEjiEhjqvbWh37FCrH1LQb-NROudJCZS4qa9j0Tyic,8845
 ioa_observe/sdk/instruments.py,sha256=cA5Yq1BYFovMrYUNYQXua-JXsMtMOa_YOn6yiJZNwLg,576
 ioa_observe/sdk/telemetry.py,sha256=6wwaOYhZMjAZ6dXDdBA2LUWo3LLptTcy93BJqDdbqBM,3103
 ioa_observe/sdk/version.py,sha256=oriNAY8huVDPw5N_rv5F_PehFrcGo37FSGBCfZCM81M,121
 ioa_observe/sdk/client/__init__.py,sha256=V4Rt-Z1EHlM12Lx3hGd0Ew70V1JKAQZXNb9ABtdWHEI,224
-ioa_observe/sdk/client/client.py,sha256=nGQoH2pGkc6QANrhfq7cgtgN0HlLxDeu6NrRaEbGHLE,2091
+ioa_observe/sdk/client/client.py,sha256=6TVOo_E1ulE3WO_CYG7oPgeucs-qegOA09uTO3yQiyk,2112
 ioa_observe/sdk/client/http.py,sha256=LdLYSQPFIhKN5BTB-N78jLO7ITl7jGjA0-qpewEIvO4,1724
 ioa_observe/sdk/config/__init__.py,sha256=8aVNaw0yRNLFPxlf97iOZLlJVcV81ivSDnudH2m1OIo,572
 ioa_observe/sdk/connectors/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 ioa_observe/sdk/connectors/slim.py,sha256=NwbKEV7d5NIOqmG8zKqtgGigSJl7kf3QJ65z2gxpsY8,8498
-ioa_observe/sdk/decorators/__init__.py,sha256=c8gzCG-CASNI61RiTpNiTvMfguWvn4zc25fhBBgbHFA,3626
-ioa_observe/sdk/decorators/base.py,sha256=KbSxFUTP_qpZA0gzt_xe4pFTu9SLpAo1MbHskQ3BQ9A,30208
+ioa_observe/sdk/decorators/__init__.py,sha256=GUZs_HA57bQTLSgo7GAnaofAapk2Y-NuE6md0HPSH3s,3603
+ioa_observe/sdk/decorators/base.py,sha256=FLICXVOFzv6yuCQL99G5Do5h1WrKJNsegvfm5KHe9v8,30173
 ioa_observe/sdk/decorators/helpers.py,sha256=I9HXMBivkZpGDtPe9Ad_UU35p_m_wEPate4r_fU0oOA,2705
 ioa_observe/sdk/decorators/util.py,sha256=IebvH9gwZN1en3LblYJUh4bAV2STl6xmp8WpZzBDH2g,30068
 ioa_observe/sdk/instrumentations/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-ioa_observe/sdk/instrumentations/a2a.py,sha256=ov_9ckkymf_qFXG0iXVWfxlW-3kFcP-knrM_t-Cf72w,4414
+ioa_observe/sdk/instrumentations/a2a.py,sha256=ZpqvPl4u-yheQzSdBfxnZhWFZ8ntbKni_uaW3IDyjqw,6309
+ioa_observe/sdk/instrumentations/mcp.py,sha256=vRM3ofnn7AMmry2RrfyZnZVPEutLWiDMghx2TSnm0Wk,18569
 ioa_observe/sdk/instrumentations/slim.py,sha256=J5e6XeshH55xXaUiT9_j4R_n6VQELzBjgRAU-AgZGOg,11435
 ioa_observe/sdk/logging/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 ioa_observe/sdk/logging/logging.py,sha256=HZxW9s8Due7jgiNkdI38cIjv5rC9D-Flta3RQMOnpow,2891
@@ -33,14 +34,15 @@ ioa_observe/sdk/tracing/content_allow_list.py,sha256=1fAkpIwUQ7vDwCTkIVrqeltWQtr
 ioa_observe/sdk/tracing/context_manager.py,sha256=O0JEXYa9h8anhW78R8KKBuqS0j4by1E1KXxNIMPnLr8,400
 ioa_observe/sdk/tracing/context_utils.py,sha256=-sYS9vPLI87davV9ubneq5xqbV583CC_c0SmOQS1TAs,2933
 ioa_observe/sdk/tracing/manual.py,sha256=KS6WN-zw9vAACzXYmnMoJm9d1fenYMfvzeK1GrGDPDE,1937
-ioa_observe/sdk/tracing/tracing.py,sha256=jU-qeIccoPUFms2uzYUHoBoACzkCqcdEW6PNzi8uz3M,38883
+ioa_observe/sdk/tracing/tracing.py,sha256=lwmatGwviSrf-hlBxRyxa0kv9AQdP302R3duBgNKsSU,47127
+ioa_observe/sdk/tracing/transform_span.py,sha256=XTApi_gJxum7ynvhtcoCfDyK8VVOj91Q1DT6hAeLHA8,8419
 ioa_observe/sdk/utils/__init__.py,sha256=UPn182U-UblF_XwXaFpx8F-TmQTbm1LYf9y89uSp5Hw,704
-ioa_observe/sdk/utils/const.py,sha256=GwbHakKPjBL4wLqAVkDrSoKB-8p18EUrbaqPuRuV_xg,1099
+ioa_observe/sdk/utils/const.py,sha256=d67dUTAH9UpWvUV9GLBUqn1Sc2knJ55dy-e6YoLrvSo,1318
 ioa_observe/sdk/utils/in_memory_span_exporter.py,sha256=H_4TRaThMO1H6vUQ0OpQvzJk_fZH0OOsRAM1iZQXsR8,2112
 ioa_observe/sdk/utils/json_encoder.py,sha256=g4NQ0tTqgWssY6I1D7r4zo0G6PiUo61jhofTAw5-jno,639
 ioa_observe/sdk/utils/package_check.py,sha256=1d1MjxhwoEZIx9dumirT2pRsEWgn-m-SI4npDeEalew,576
-ioa_observe_sdk-1.0.15.dist-info/licenses/LICENSE.md,sha256=55VjUfgjWOS4vv3Cf55gfq-RxjPgRIO2vlgYPUuC5lA,11362
-ioa_observe_sdk-1.0.15.dist-info/METADATA,sha256=WwtaLg1AX6BXTs0ar7ru1rJ2GRKfoFMMpv8raR1FNLM,6799
-ioa_observe_sdk-1.0.15.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-ioa_observe_sdk-1.0.15.dist-info/top_level.txt,sha256=Yt-6Y1olZEDqCs2REeqI30WjYx0pLGQSVqzYmDd67N8,12
-ioa_observe_sdk-1.0.15.dist-info/RECORD,,
+ioa_observe_sdk-1.0.16.dist-info/licenses/LICENSE.md,sha256=55VjUfgjWOS4vv3Cf55gfq-RxjPgRIO2vlgYPUuC5lA,11362
+ioa_observe_sdk-1.0.16.dist-info/METADATA,sha256=j8GCTBcPggbbhImBhXvPU6JobBfV-HLwuE_2952sLao,7027
+ioa_observe_sdk-1.0.16.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+ioa_observe_sdk-1.0.16.dist-info/top_level.txt,sha256=Yt-6Y1olZEDqCs2REeqI30WjYx0pLGQSVqzYmDd67N8,12
+ioa_observe_sdk-1.0.16.dist-info/RECORD,,