monocle-apptrace 0.4.1__py3-none-any.whl → 0.5.0__py3-none-any.whl

monocle_apptrace/instrumentation/common/utils.py

@@ -11,6 +11,8 @@ from opentelemetry.propagate import extract
 from opentelemetry import baggage
 from monocle_apptrace.instrumentation.common.constants import MONOCLE_SCOPE_NAME_PREFIX, SCOPE_METHOD_FILE, SCOPE_CONFIG_PATH, llm_type_map, MONOCLE_SDK_VERSION, ADD_NEW_WORKFLOW
 from importlib.metadata import version
+from opentelemetry.trace.span import INVALID_SPAN
+_MONOCLE_SPAN_KEY = "monocle" + _SPAN_KEY
 
 T = TypeVar('T')
 U = TypeVar('U')
@@ -70,7 +72,7 @@ def with_tracer_wrapper(func):
     """Helper for providing tracer for wrapper functions."""
 
     def _with_tracer(tracer, handler, to_wrap):
-        def wrapper(wrapped, instance, args, kwargs):
+        def wrapper(wrapped, instance, args, kwargs, source_path=None):
             try:
                 # get and log the parent span context if injected by the application
                 # This is useful for debugging and tracing of Azure functions
@@ -83,12 +85,12 @@ def with_tracer_wrapper(func):
                             f"Parent span is found with trace id {hex(parent_span.get_span_context().trace_id)}")
             except Exception as e:
                 logger.error("Exception in attaching parent context: %s", e)
-
-            if traceback.extract_stack().__len__() > 2:
-                filename, line_number, _, _ = traceback.extract_stack()[-2]
-                source_path = f"{filename}:{line_number}"
-            else:
-                source_path = ""
+            if not source_path:
+                if traceback.extract_stack().__len__() > 2:
+                    filename, line_number, _, _ = traceback.extract_stack()[-2]
+                    source_path = f"{filename}:{line_number}"
+                else:
+                    source_path = ""
             val = func(tracer, handler, to_wrap, wrapped, instance, source_path, args, kwargs)
             return val
 
@@ -152,13 +154,6 @@ def flatten_dict(d, parent_key='', sep='_'):
             items.append((new_key, v))
     return dict(items)
 
-def get_fully_qualified_class_name(instance):
-    if instance is None:
-        return None
-    module_name = instance.__class__.__module__
-    qualname = instance.__class__.__qualname__
-    return f"{module_name}.{qualname}"
-
 # returns json path like key probe in a dictionary
 def get_nested_value(data, keys):
     for key in keys:
@@ -330,6 +325,12 @@ def add_monocle_trace_state(headers:dict[str:str]) -> None:
     else:
         headers['tracestate'] = monocle_trace_state
 
+def get_json_dumps(obj) -> str:
+    try:
+        return json.dumps(obj)
+    except TypeError as e:
+        return str(obj)
+
 class Option(Generic[T]):
     def __init__(self, value: Optional[T]):
         self.value = value
@@ -392,6 +393,13 @@ def get_exception_message(arguments):
     else:
         return ''
 
+def get_error_message(arguments):
+    status_code = get_status_code(arguments)
+    if status_code == 'success':
+        return ''
+    else:
+        return status_code
+
 def get_status_code(arguments):
     if arguments["exception"] is not None:
         return get_exception_status_code(arguments)
@@ -422,4 +430,33 @@ def patch_instance_method(obj, method_name, func):
     new_cls = type(f"Patched{cls.__name__}", (cls,), {
         method_name: func
     })
-    obj.__class__ = new_cls
+    obj.__class__ = new_cls
+
+
+def set_monocle_span_in_context(
+    span: Span, context: Optional[Context] = None
+) -> Context:
+    """Set the span in the given context.
+
+    Args:
+        span: The Span to set.
+        context: a Context object. if one is not passed, the
+            default current context is used instead.
+    """
+    ctx = set_value(_MONOCLE_SPAN_KEY, span, context=context)
+    return ctx
+
+def get_current_monocle_span(context: Optional[Context] = None) -> Span:
+    """Retrieve the current span.
+
+    Args:
+        context: A Context object. If one is not passed, the
+            default current context is used instead.
+
+    Returns:
+        The Span set in the context if it exists. INVALID_SPAN otherwise.
+    """
+    span = get_value(_MONOCLE_SPAN_KEY, context=context)
+    if span is None or not isinstance(span, Span):
+        return INVALID_SPAN
+    return span

monocle_apptrace/instrumentation/common/wrapper.py

@@ -1,19 +1,28 @@
 # pylint: disable=protected-access
+from contextlib import contextmanager
+import os
+from typing import AsyncGenerator, Iterator, Optional
 import logging
 from opentelemetry.trace import Tracer
+from opentelemetry.trace.propagation import _SPAN_KEY, set_span_in_context, get_current_span
+from opentelemetry.trace import propagation
 from opentelemetry.context import set_value, attach, detach, get_value
+from opentelemetry.context import create_key, get_value, set_value
+from opentelemetry.context.context import Context
+from opentelemetry.trace.span import INVALID_SPAN, Span
 
 from monocle_apptrace.instrumentation.common.span_handler import SpanHandler
 from monocle_apptrace.instrumentation.common.utils import (
-    get_fully_qualified_class_name,
     set_scopes,
     with_tracer_wrapper,
     set_scope,
     remove_scope,
-    get_parent_span
+    get_current_monocle_span,
+    set_monocle_span_in_context
 )
 from monocle_apptrace.instrumentation.common.constants import WORKFLOW_TYPE_KEY, ADD_NEW_WORKFLOW
 logger = logging.getLogger(__name__)
+ISOLATE_MONOCLE_SPANS = os.getenv("MONOCLE_ISOLATE_SPANS", "true").lower() == "true"
 
 def get_auto_close_span(to_wrap, kwargs):
     try:
@@ -36,15 +45,17 @@ def pre_process_span(name, tracer, handler, add_workflow_span, to_wrap, wrapped,
         except Exception as e:
             logger.info(f"Warning: Error occurred in pre_task_processing: {e}")
 
-def post_process_span(handler, to_wrap, wrapped, instance, args, kwargs, return_value, span, parent_span=None, ex = None):
+def post_process_span(handler, to_wrap, wrapped, instance, args, kwargs, return_value, span, parent_span, ex):
     if not (SpanHandler.is_root_span(span) or get_value(ADD_NEW_WORKFLOW) == True):
         try:
+            if parent_span == INVALID_SPAN:
+                parent_span = None
             handler.hydrate_span(to_wrap, wrapped, instance, args, kwargs, return_value, span, parent_span, ex)
         except Exception as e:
             logger.info(f"Warning: Error occurred in hydrate_span: {e}")
         
         try:
-            handler.post_task_processing(to_wrap, wrapped, instance, args, kwargs, return_value, span)
+            handler.post_task_processing(to_wrap, wrapped, instance, args, kwargs, return_value, ex, span, parent_span)
         except Exception as e:
             logger.info(f"Warning: Error occurred in post_task_processing: {e}")
 
@@ -52,7 +63,7 @@ def get_span_name(to_wrap, instance):
     if to_wrap.get("span_name"):
         name = to_wrap.get("span_name")
     else:
-        name = get_fully_qualified_class_name(instance)
+        name = to_wrap.get("package", "") + "." + to_wrap.get("object", "") + "." + to_wrap.get("method", "")
     return name
 
 def monocle_wrapper_span_processor(tracer: Tracer, handler: SpanHandler, to_wrap, wrapped, instance, source_path, add_workflow_span, args, kwargs):
@@ -61,8 +72,8 @@ def monocle_wrapper_span_processor(tracer: Tracer, handler: SpanHandler, to_wrap
     return_value = None
     span_status = None
     auto_close_span = get_auto_close_span(to_wrap, kwargs)
-    parent_span = get_parent_span()
-    with tracer.start_as_current_span(name, end_on_exit=auto_close_span) as span:
+    parent_span = get_current_monocle_span()
+    with start_as_monocle_span(tracer, name, auto_close_span) as span:
         pre_process_span(name, tracer, handler, add_workflow_span, to_wrap, wrapped, instance, args, kwargs, span, source_path)
         
         if SpanHandler.is_root_span(span) or add_workflow_span:
@@ -93,10 +104,11 @@ def monocle_wrapper_span_processor(tracer: Tracer, handler: SpanHandler, to_wrap
 
 def monocle_wrapper(tracer: Tracer, handler: SpanHandler, to_wrap, wrapped, instance, source_path, args, kwargs):
     return_value = None
+    pre_trace_token = None
     token = None
     try:
         try:
-            handler.pre_tracing(to_wrap, wrapped, instance, args, kwargs)
+            pre_trace_token = handler.pre_tracing(to_wrap, wrapped, instance, args, kwargs)
         except Exception as e:
             logger.info(f"Warning: Error occurred in pre_tracing: {e}")
         if to_wrap.get('skip_span', False) or handler.skip_span(to_wrap, wrapped, instance, args, kwargs):
@@ -111,18 +123,19 @@ def monocle_wrapper(tracer: Tracer, handler: SpanHandler, to_wrap, wrapped, inst
         return return_value
     finally:
         try:
-            handler.post_tracing(to_wrap, wrapped, instance, args, kwargs, return_value)
+            handler.post_tracing(to_wrap, wrapped, instance, args, kwargs, return_value, token=pre_trace_token)
         except Exception as e:
             logger.info(f"Warning: Error occurred in post_tracing: {e}")
 
-async def amonocle_wrapper_span_processor(tracer: Tracer, handler: SpanHandler, to_wrap, wrapped, instance, source_path, add_workflow_span, args, kwargs):
+async def amonocle_wrapper_span_processor(tracer: Tracer, handler: SpanHandler, to_wrap, wrapped, instance, source_path, add_workflow_span,
+                                        args, kwargs):
     # Main span processing logic
     name = get_span_name(to_wrap, instance)
     return_value = None
     span_status = None
     auto_close_span = get_auto_close_span(to_wrap, kwargs)
-    parent_span = get_parent_span()
-    with tracer.start_as_current_span(name, end_on_exit=auto_close_span) as span:
+    parent_span = get_current_monocle_span()
+    with start_as_monocle_span(tracer, name, auto_close_span) as span:
         pre_process_span(name, tracer, handler, add_workflow_span, to_wrap, wrapped, instance, args, kwargs, span, source_path)
         
         if SpanHandler.is_root_span(span) or add_workflow_span:
@@ -141,7 +154,7 @@ async def amonocle_wrapper_span_processor(tracer: Tracer, handler: SpanHandler,
                 raise
             finally:
                 def post_process_span_internal(ret_val):
-                    post_process_span(handler, to_wrap, wrapped, instance, args, kwargs, ret_val, span, parent_span,ex)
+                    post_process_span(handler, to_wrap, wrapped, instance, args, kwargs, ret_val, span, parent_span, ex)
                     if not auto_close_span:
                         span.end()
                 if ex is None and not auto_close_span and to_wrap.get("output_processor") and to_wrap.get("output_processor").get("response_processor"):
@@ -149,14 +162,54 @@ async def amonocle_wrapper_span_processor(tracer: Tracer, handler: SpanHandler,
                 else:
                     post_process_span_internal(return_value)
         span_status = span.status
-    return return_value, span.status
+    return return_value, span_status
+
+async def amonocle_iter_wrapper_span_processor(tracer: Tracer, handler: SpanHandler, to_wrap, wrapped, instance, source_path, add_workflow_span,
+                                        args, kwargs) -> AsyncGenerator[any, None]:
+    # Main span processing logic
+    name = get_span_name(to_wrap, instance)
+    auto_close_span = get_auto_close_span(to_wrap, kwargs)
+    parent_span = get_current_monocle_span()
+    last_item = None
+
+    with start_as_monocle_span(tracer, name, auto_close_span) as span:
+        pre_process_span(name, tracer, handler, add_workflow_span, to_wrap, wrapped, instance, args, kwargs, span, source_path)
+
+        if SpanHandler.is_root_span(span) or add_workflow_span:
+            # Recursive call for the actual span
+            async for item in amonocle_iter_wrapper_span_processor(tracer, handler, to_wrap, wrapped, instance, source_path, False, args, kwargs):
+                yield item
+
+            if not auto_close_span:
+                span.end()
+        else:
+            ex:Exception = None
+            try:
+                with SpanHandler.workflow_type(to_wrap, span):
+                    async for item in wrapped(*args, **kwargs):
+                        last_item = item
+                        yield item
+            except Exception as e:
+                ex = e
+                raise
+            finally:
+                def post_process_span_internal(ret_val):
+                    post_process_span(handler, to_wrap, wrapped, instance, args, kwargs, ret_val, span, parent_span, ex)
+                    if not auto_close_span:
+                        span.end()
+                if ex is None and not auto_close_span and to_wrap.get("output_processor") and to_wrap.get("output_processor").get("response_processor"):
+                    to_wrap.get("output_processor").get("response_processor")(to_wrap, None, post_process_span_internal)
+                else:
+                    post_process_span_internal(last_item)
+    return
 
 async def amonocle_wrapper(tracer: Tracer, handler: SpanHandler, to_wrap, wrapped, instance, source_path, args, kwargs):
     return_value = None
     token = None
+    pre_trace_token = None
     try:
         try:
-            handler.pre_tracing(to_wrap, wrapped, instance, args, kwargs)
+            pre_trace_token = handler.pre_tracing(to_wrap, wrapped, instance, args, kwargs)
         except Exception as e:
             logger.info(f"Warning: Error occurred in pre_tracing: {e}")
         if to_wrap.get('skip_span', False) or handler.skip_span(to_wrap, wrapped, instance, args, kwargs):
@@ -165,13 +218,40 @@ async def amonocle_wrapper(tracer: Tracer, handler: SpanHandler, to_wrap, wrappe
             add_workflow_span = get_value(ADD_NEW_WORKFLOW) == True
             token = attach(set_value(ADD_NEW_WORKFLOW, False))
             try:
-                return_value, span_status = await amonocle_wrapper_span_processor(tracer, handler, to_wrap, wrapped, instance, source_path, add_workflow_span, args, kwargs)    
+                return_value, span_status = await amonocle_wrapper_span_processor(tracer, handler, to_wrap, wrapped, instance, source_path, 
+                                                                        add_workflow_span, args, kwargs)
             finally:
                 detach(token)
         return return_value
     finally:
         try:
-            handler.post_tracing(to_wrap, wrapped, instance, args, kwargs, return_value)
+            handler.post_tracing(to_wrap, wrapped, instance, args, kwargs, return_value, pre_trace_token)
+        except Exception as e:
+            logger.info(f"Warning: Error occurred in post_tracing: {e}")
+
+async def amonocle_iter_wrapper(tracer: Tracer, handler: SpanHandler, to_wrap, wrapped, instance, source_path, args, kwargs) -> AsyncGenerator[any, None]:
+    token = None
+    pre_trace_token = None
+    try:
+        try:
+            pre_trace_token = handler.pre_tracing(to_wrap, wrapped, instance, args, kwargs)
+        except Exception as e:
+            logger.info(f"Warning: Error occurred in pre_tracing: {e}")
+        if to_wrap.get('skip_span', False) or handler.skip_span(to_wrap, wrapped, instance, args, kwargs):
+            async for item in wrapped(*args, **kwargs):
+                yield item
+        else:
+            add_workflow_span = get_value(ADD_NEW_WORKFLOW) == True
+            token = attach(set_value(ADD_NEW_WORKFLOW, False))
+            try:
+                async for item in amonocle_iter_wrapper_span_processor(tracer, handler, to_wrap, wrapped, instance, source_path, add_workflow_span, args, kwargs):
+                    yield item
+            finally:
+                detach(token)
+        return
+    finally:
+        try:
+            handler.post_tracing(to_wrap, wrapped, instance, args, kwargs, None, pre_trace_token)
         except Exception as e:
             logger.info(f"Warning: Error occurred in post_tracing: {e}")
 
@@ -183,6 +263,12 @@ def task_wrapper(tracer: Tracer, handler: SpanHandler, to_wrap, wrapped, instanc
 async def atask_wrapper(tracer: Tracer, handler: SpanHandler, to_wrap, wrapped, instance, source_path, args, kwargs):
     return await amonocle_wrapper(tracer, handler, to_wrap, wrapped, instance, source_path, args, kwargs)
 
+@with_tracer_wrapper
+async def atask_iter_wrapper(tracer: Tracer, handler: SpanHandler, to_wrap, wrapped, instance, source_path, args, kwargs) -> AsyncGenerator[any, None]:
+    async for item in amonocle_iter_wrapper(tracer, handler, to_wrap, wrapped, instance, source_path, args, kwargs):
+        yield item
+    return
+
 @with_tracer_wrapper
 def scope_wrapper(tracer: Tracer, handler: SpanHandler, to_wrap, wrapped, instance, source_path, args, kwargs):
     scope_name = to_wrap.get('scope_name', None)
@@ -244,4 +330,24 @@ def evaluate_scope_values(args, kwargs, to_wrap, scope_values):
             scope_values = None
     if isinstance(scope_values, dict):
         return scope_values
-    return None
+    return None
+
+@contextmanager
+def start_as_monocle_span(tracer: Tracer, name: str, auto_close_span: bool) -> Iterator["Span"]:
+    """ Wrapper to OTEL start_as_current_span to isolate monocle and non monocle spans.
+        This essentiall links monocle and non-monocle spans separately which is default behavior.
+        It can be optionally overridden by setting the environment variable MONOCLE_ISOLATE_SPANS to false.
+    """
+    if not ISOLATE_MONOCLE_SPANS:
+        # If not isolating, use the default start_as_current_span
+        yield tracer.start_as_current_span(name, end_on_exit=auto_close_span)
+        return
+    original_span = get_current_span()
+    monocle_span_token = attach(set_span_in_context(get_current_monocle_span()))
+    with tracer.start_as_current_span(name, end_on_exit=auto_close_span) as span:
+        new_monocle_token = attach(set_monocle_span_in_context(span))
+        original_span_token = attach(set_span_in_context(original_span))
+        yield span
+        detach(original_span_token)
+        detach(new_monocle_token)
+    detach(monocle_span_token)

monocle_apptrace/instrumentation/common/wrapper_method.py

@@ -9,10 +9,14 @@ from monocle_apptrace.instrumentation.metamodel.langchain.methods import (
     LANGCHAIN_METHODS,
 )
 from monocle_apptrace.instrumentation.metamodel.llamaindex.methods import (LLAMAINDEX_METHODS, )
+from monocle_apptrace.instrumentation.metamodel.llamaindex.llamaindex_processor import LlamaIndexToolHandler, LlamaIndexAgentHandler, LlamaIndexSingleAgenttToolHandlerWrapper
 from monocle_apptrace.instrumentation.metamodel.haystack.methods import (HAYSTACK_METHODS, )
 from monocle_apptrace.instrumentation.metamodel.openai.methods import (OPENAI_METHODS,)
 from monocle_apptrace.instrumentation.metamodel.openai._helper import OpenAISpanHandler
 from monocle_apptrace.instrumentation.metamodel.langgraph.methods import LANGGRAPH_METHODS
+from monocle_apptrace.instrumentation.metamodel.langgraph.langgraph_processor import LanggraphAgentHandler, LanggraphToolHandler
+from monocle_apptrace.instrumentation.metamodel.agents.methods import AGENTS_METHODS
+from monocle_apptrace.instrumentation.metamodel.agents.agents_processor import AgentsSpanHandler
 from monocle_apptrace.instrumentation.metamodel.flask.methods import (FLASK_METHODS, )
 from monocle_apptrace.instrumentation.metamodel.flask._helper import FlaskSpanHandler, FlaskResponseSpanHandler
 from monocle_apptrace.instrumentation.metamodel.requests.methods import (REQUESTS_METHODS, )
@@ -23,6 +27,17 @@ from monocle_apptrace.instrumentation.metamodel.aiohttp.methods import (AIOHTTP_
 from monocle_apptrace.instrumentation.metamodel.aiohttp._helper import aiohttpSpanHandler
 from monocle_apptrace.instrumentation.metamodel.azfunc._helper import (azureSpanHandler)
 from monocle_apptrace.instrumentation.metamodel.azfunc.methods import AZFUNC_HTTP_METHODS
+from monocle_apptrace.instrumentation.metamodel.gemini.methods import GEMINI_METHODS
+from monocle_apptrace.instrumentation.metamodel.fastapi.methods import FASTAPI_METHODS
+from monocle_apptrace.instrumentation.metamodel.fastapi._helper import FastAPISpanHandler, FastAPIResponseSpanHandler
+from monocle_apptrace.instrumentation.metamodel.lambdafunc._helper import lambdaSpanHandler
+from monocle_apptrace.instrumentation.metamodel.lambdafunc.methods import LAMBDA_HTTP_METHODS
+from monocle_apptrace.instrumentation.metamodel.mcp.methods import MCP_METHODS
+from monocle_apptrace.instrumentation.metamodel.mcp.mcp_processor import MCPAgentHandler
+from monocle_apptrace.instrumentation.metamodel.a2a.methods import A2A_CLIENT_METHODS
+from monocle_apptrace.instrumentation.metamodel.litellm.methods import LITELLM_METHODS
+from monocle_apptrace.instrumentation.metamodel.adk.methods import ADK_METHODS
+
 class WrapperMethod:
     def __init__(
             self,
@@ -71,7 +86,29 @@ class WrapperMethod:
     def get_span_handler(self) -> SpanHandler:
         return self.span_handler()
 
-DEFAULT_METHODS_LIST = LANGCHAIN_METHODS + LLAMAINDEX_METHODS + HAYSTACK_METHODS + BOTOCORE_METHODS + FLASK_METHODS + REQUESTS_METHODS + LANGGRAPH_METHODS + OPENAI_METHODS + TEAMAI_METHODS + ANTHROPIC_METHODS + AIOHTTP_METHODS + AZURE_AI_INFERENCE_METHODS + AZFUNC_HTTP_METHODS
+DEFAULT_METHODS_LIST = (
+    LANGCHAIN_METHODS + 
+    LLAMAINDEX_METHODS + 
+    HAYSTACK_METHODS + 
+    BOTOCORE_METHODS + 
+    FLASK_METHODS + 
+    REQUESTS_METHODS + 
+    LANGGRAPH_METHODS + 
+    AGENTS_METHODS +
+    OPENAI_METHODS + 
+    TEAMAI_METHODS +
+    ANTHROPIC_METHODS + 
+    AIOHTTP_METHODS + 
+    AZURE_AI_INFERENCE_METHODS + 
+    AZFUNC_HTTP_METHODS + 
+    GEMINI_METHODS + 
+    FASTAPI_METHODS + 
+    LAMBDA_HTTP_METHODS +
+    MCP_METHODS + 
+    A2A_CLIENT_METHODS +
+    LITELLM_METHODS +
+    ADK_METHODS
+)
 
 MONOCLE_SPAN_HANDLERS: Dict[str, SpanHandler] = {
     "default": SpanHandler(),
@@ -83,4 +120,14 @@ MONOCLE_SPAN_HANDLERS: Dict[str, SpanHandler] = {
     "non_framework_handler": NonFrameworkSpanHandler(),
     "openai_handler": OpenAISpanHandler(),
     "azure_func_handler": azureSpanHandler(),
+    "mcp_agent_handler": MCPAgentHandler(),
+    "fastapi_handler": FastAPISpanHandler(),
+    "fastapi_response_handler": FastAPIResponseSpanHandler(),
+    "langgraph_agent_handler": LanggraphAgentHandler(),
+    "langgraph_tool_handler": LanggraphToolHandler(),
+    "agents_agent_handler": AgentsSpanHandler(),
+    "llamaindex_tool_handler": LlamaIndexToolHandler(),
+    "llamaindex_agent_handler": LlamaIndexAgentHandler(),
+    "llamaindex_single_agent_tool_handler": LlamaIndexSingleAgenttToolHandlerWrapper(),
+    "lambda_func_handler": lambdaSpanHandler(),
 }

monocle_apptrace/instrumentation/metamodel/a2a/_helper.py

@@ -0,0 +1,37 @@
+from opentelemetry.context import get_value
+from monocle_apptrace.instrumentation.common.utils import resolve_from_alias
+import logging
+import json
+
+logger = logging.getLogger(__name__)
+
+def get_url(arguments):
+    """Get the URL of the tool from the instance."""
+    return arguments["instance"].url
+
+def get_method(arguments):
+    """Get the method of the tool from the instance."""
+    return arguments["args"][0].method
+
+def get_params_arguments(arguments):
+    """Get the params of the tool from the instance."""
+    return arguments["args"][0].params.message.parts[0].root.text
+
+def get_role(arguments):
+    """Get the role of the tool from the instance."""
+    return arguments["args"][0].params.message.role.value
+
+def get_status(arguments):
+    """Get the status of the tool from the result."""
+    return arguments["result"].root.result.status.state.value
+
+def get_response(arguments):
+    """Get the response of the tool from the result."""
+    ret_val = []
+    for artifact in arguments["result"].root.result.artifacts:
+        if artifact.parts:
+            for part in artifact.parts:
+                if part.root.text:
+                    ret_val.append(part.root.text)
+    return ret_val
+    # return arguments["result"].root.result.artifacts[0].parts[0].root.text

monocle_apptrace/instrumentation/metamodel/a2a/entities/inference.py

@@ -0,0 +1,112 @@
+from monocle_apptrace.instrumentation.metamodel.a2a import _helper
+
+A2A_CLIENT = {
+    "type": "agentic.invocation",
+    "attributes": [
+        [
+            {
+                "attribute": "type",
+                "accessor": lambda arguments: "agent2agent.server"
+            },
+            {
+                "attribute": "url",
+                "accessor": lambda arguments: _helper.get_url(arguments)
+            },
+            {
+                "attribute": "method",
+                "accessor": lambda arguments: _helper.get_method(arguments)
+            }
+        ]
+    ],
+    "events": [
+        {
+            "name": "data.input",
+            "attributes": [
+                {
+                    "_comment": "this is a2a input",
+                    "attribute": "input",
+                    "accessor": lambda arguments: _helper.get_params_arguments(arguments)
+                },
+                {
+                    "_comment": "this is a2a input",
+                    "attribute": "role",
+                    "accessor": lambda arguments: _helper.get_role(arguments)
+                },
+            ],
+        },
+        {
+            "name": "data.output",
+            "attributes": [
+                {
+                    "_comment": "this is a2a output",
+                    "attribute": "status",
+                    "accessor": lambda arguments: _helper.get_status(arguments, "status")
+                },
+                {
+                    "_comment": "this is a2a output",
+                    "attribute": "response",
+                    "accessor": lambda arguments: _helper.get_response(arguments)   
+                },
+            ],
+        },
+    ],
+}
+
+# A2A_RESOLVE = {
+#     "type": "a2a.resolve",
+#     "attributes": [
+#         [
+#             # {
+#             #   "_comment": "tool type",
+#             #   "attribute": "type",
+#             #   "accessor": lambda arguments:'tool.mcp'
+#             # },
+#             {
+#                 "_comment": "name of the tool",
+#                 "attribute": "name",
+#                 "accessor": lambda arguments: _helper.log(arguments),
+#             },
+#                         {
+#                 "_comment": "tool description",
+#                 "attribute": "agent_description",
+#                 "accessor": lambda arguments: arguments["result"].description
+#             },
+#             {
+#                 "_comment": "tool name",
+#                 "attribute": "agent_name",
+#                 "accessor": lambda arguments: arguments["result"].name
+#             }
+#             # {
+#             #     "_comment": "tool type",
+#             #     "attribute": "type",
+#             #     "accessor": lambda arguments: _helper.get_type(arguments),
+#             # },
+#         ]
+#     ],
+#     "events": [
+#         # {
+#         #     "name": "data.input",
+#         #     "attributes": [
+#         #         {
+#         #             "_comment": "this is Tool input",
+#         #             "attribute": "input",
+#         #             "accessor": lambda arguments: _helper.get_params_arguments(
+#         #                 arguments
+#         #             ),
+#         #         },
+#         #     ],
+#         # },
+#         # {
+#         #     "name": "data.output",
+#         #     "attributes": [
+#         #         {
+#         #             "_comment": "this is Tool output",
+#         #             "attribute": "output",
+#         #             "accessor": lambda arguments: _helper.get_output_text(arguments)
+#         #         },
+#         #     ],
+#         # },
+#     ],
+# }
+
+

monocle_apptrace/instrumentation/metamodel/a2a/methods.py

@@ -0,0 +1,22 @@
+from monocle_apptrace.instrumentation.common.wrapper import task_wrapper, atask_wrapper
+from monocle_apptrace.instrumentation.metamodel.a2a.entities.inference import A2A_CLIENT
+
+A2A_CLIENT_METHODS = [
+    # {
+    #     "package": "a2a.client.client",
+    #     "object": "A2ACardResolver",
+    #     "method": "get_agent_card",
+    #     "wrapper_method": atask_wrapper,
+    #     # "span_handler": "mcp_agent_handler",
+    #     "output_processor": A2A_RESOLVE,
+    # },
+    {
+        "package": "a2a.client.client",
+        "object": "A2AClient",
+        "method": "send_message",
+        "wrapper_method": atask_wrapper,
+        "output_processor": A2A_CLIENT,
+    },
+]
+
+