monocle-apptrace 0.5.3__py3-none-any.whl → 0.6.6__py3-none-any.whl

monocle_apptrace/instrumentation/common/wrapper.py

@@ -1,28 +1,35 @@
 # pylint: disable=protected-access
+import logging
+import os
 from contextlib import contextmanager
 import os
-from typing import AsyncGenerator, Iterator, Optional
+from typing import AsyncGenerator, Iterator
 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.trace.propagation import set_span_in_context, get_current_span
 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 opentelemetry.trace.status import StatusCode
 
+from monocle_apptrace.instrumentation.common.constants import (
+    ADD_NEW_WORKFLOW,
+    AGENTIC_SPANS,
+    WORKFLOW_TYPE_KEY,
+)
+from monocle_apptrace.instrumentation.common.scope_wrapper import monocle_trace_scope
 from monocle_apptrace.instrumentation.common.span_handler import SpanHandler
 from monocle_apptrace.instrumentation.common.utils import (
+    get_current_monocle_span,
+    remove_scope,
+    set_monocle_span_in_context,
+    set_scope,
     set_scopes,
     with_tracer_wrapper,
     set_scope,
     remove_scope,
     get_current_monocle_span,
-    set_monocle_span_in_context
+    set_monocle_span_in_context,
 )
-from monocle_apptrace.instrumentation.common.constants import WORKFLOW_TYPE_KEY, ADD_NEW_WORKFLOW, AGENTIC_SPANS
-from monocle_apptrace.instrumentation.common.scope_wrapper import monocle_trace_scope
 
 logger = logging.getLogger(__name__)
 ISOLATE_MONOCLE_SPANS = os.getenv("MONOCLE_ISOLATE_SPANS", "true").lower() == "true"
@@ -53,7 +60,9 @@ def post_process_span(handler, to_wrap, wrapped, instance, args, kwargs, return_
         try:
             if parent_span == INVALID_SPAN:
                 parent_span = None
-            handler.hydrate_span(to_wrap, wrapped, instance, args, kwargs, return_value, span, parent_span, ex)
+            handler.hydrate_span(to_wrap, wrapped, instance, args, kwargs, return_value, span, parent_span, ex,
+                    is_post_exec=True)
+            return_value = SpanHandler.replace_placeholders_in_response(return_value, span)
         except Exception as e:
             logger.info(f"Warning: Error occurred in hydrate_span: {e}")
         
@@ -61,6 +70,7 @@ def post_process_span(handler, to_wrap, wrapped, instance, args, kwargs, return_
             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}")
+        return return_value
 
 def get_span_name(to_wrap, instance):
     if to_wrap.get("span_name"):
@@ -87,19 +97,32 @@ def monocle_wrapper_span_processor(tracer: Tracer, handler: SpanHandler, to_wrap
                 span.end()
         else:
             ex:Exception = None
-            to_wrap = get_wrapper_with_next_processor(to_wrap, handler, instance, args, kwargs)
+            to_wrap = get_wrapper_with_next_processor(to_wrap, handler, instance, span, parent_span, args, kwargs)
             if has_more_processors(to_wrap):
                 try:
-                    return_value, span_status = monocle_wrapper_span_processor(tracer, handler, to_wrap, wrapped, instance, source_path, False, args, kwargs)
+                    handler.hydrate_span(to_wrap, wrapped, instance, args, kwargs, None, span, parent_span, ex,
+                                is_post_exec=False)
+                except Exception as e:
+                    logger.info(f"Warning: Error occurred in hydrate_span pre_process_span: {e}")
+                try:
+                    with monocle_trace_scope(get_builtin_scope_names(to_wrap)):
+                        return_value, span_status = monocle_wrapper_span_processor(tracer, handler, to_wrap, wrapped, instance, source_path, False, args, kwargs)
                 except Exception as e:
                     ex = e
                     raise
                 finally:
-                    post_process_span_internal(return_value)
+                    return_value = post_process_span(handler, to_wrap, wrapped, instance, args, kwargs, return_value, span, parent_span ,ex)
             else:
                 try:
-                    with SpanHandler.workflow_type(to_wrap, span):
-                        return_value = wrapped(*args, **kwargs)
+                    handler.hydrate_span(to_wrap, wrapped, instance, args, kwargs, None, span, parent_span, ex,
+                                is_post_exec=False)
+                except Exception as e:
+                    logger.info(f"Warning: Error occurred in hydrate_span pre_process_span: {e}")
+                try:
+                    skip_execution, return_value = SpanHandler.skip_execution(span)
+                    if not skip_execution:
+                        with SpanHandler.workflow_type(to_wrap, span):
+                            return_value = wrapped(*args, **kwargs)
                 except Exception as e:
                     ex = e
                     raise
@@ -108,10 +131,11 @@ def monocle_wrapper_span_processor(tracer: Tracer, handler: SpanHandler, to_wrap
                         post_process_span(handler, to_wrap, wrapped, instance, args, kwargs, ret_val, span, parent_span ,ex)
                         if not auto_close_span:
                             span.end()
+                        return ret_val
                     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, return_value, post_process_span_internal)
                     else:
-                        post_process_span_internal(return_value)
+                        return_value = post_process_span_internal(return_value)
             span_status = span.status
     return return_value, span_status
 
@@ -121,7 +145,9 @@ def monocle_wrapper(tracer: Tracer, handler: SpanHandler, to_wrap, wrapped, inst
     token = None
     try:
         try:
-            pre_trace_token = handler.pre_tracing(to_wrap, wrapped, instance, args, kwargs)
+            pre_trace_token, alternate_to_wrapp = handler.pre_tracing(to_wrap, wrapped, instance, args, kwargs)
+            if alternate_to_wrapp is not None:
+                to_wrap = alternate_to_wrapp
         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):
@@ -160,31 +186,46 @@ async def amonocle_wrapper_span_processor(tracer: Tracer, handler: SpanHandler,
                 span.end()
         else:
             ex:Exception = None
-            to_wrap = get_wrapper_with_next_processor(to_wrap, handler, instance, args, kwargs)
+            to_wrap = get_wrapper_with_next_processor(to_wrap, handler, instance, span, parent_span,args, kwargs)
             if has_more_processors(to_wrap):
                 try:
-                    return_value, span_status = await amonocle_wrapper_span_processor(tracer, handler, to_wrap, wrapped, instance, source_path, False, args, kwargs)
+                    handler.hydrate_span(to_wrap, wrapped, instance, args, kwargs, None, span, parent_span, ex,
+                                    is_post_exec=False)
+                except Exception as e:
+                    logger.info(f"Warning: Error occurred in hydrate_span pre_process_span: {e}")
+
+                try:
+                    with monocle_trace_scope(get_builtin_scope_names(to_wrap)):
+                        return_value, span_status = await amonocle_wrapper_span_processor(tracer, handler, to_wrap, wrapped, instance, source_path, False, args, kwargs)
                 except Exception as e:
                     ex = e
                     raise
                 finally:
-                    post_process_span_internal(return_value)
+                    return_value = post_process_span(handler, to_wrap, wrapped, instance, args, kwargs, return_value, span, parent_span ,ex)
             else:
                 try:
-                    with SpanHandler.workflow_type(to_wrap, span):
-                        return_value = await wrapped(*args, **kwargs)
+                    handler.hydrate_span(to_wrap, wrapped, instance, args, kwargs, None, span, parent_span, ex,
+                                is_post_exec=False)
+                except Exception as e:
+                    logger.info(f"Warning: Error occurred in hydrate_span pre_process_span: {e}")
+                try:
+                    skip_execution, return_value = SpanHandler.skip_execution(span)
+                    if not skip_execution:
+                        with SpanHandler.workflow_type(to_wrap, span):
+                            return_value = await wrapped(*args, **kwargs)
                 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)
+                        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()
+                        return ret_val
                     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, return_value, post_process_span_internal)
                     else:
-                        post_process_span_internal(return_value)
+                        return_value = post_process_span_internal(return_value)
         span_status = span.status
     return return_value, span_status
 
@@ -208,35 +249,50 @@ async def amonocle_iter_wrapper_span_processor(tracer: Tracer, handler: SpanHand
                 span.end()
         else:
             ex:Exception = None
-            to_wrap = get_wrapper_with_next_processor(to_wrap, handler, instance, args, kwargs)
+            to_wrap = get_wrapper_with_next_processor(to_wrap, handler, span, parent_span, instance, args, kwargs)
             if has_more_processors(to_wrap):
                 try:
-                    async for item in amonocle_iter_wrapper_span_processor(tracer, handler, to_wrap, wrapped, instance, source_path, False, args, kwargs):
-                        last_item = item
-                        yield item
+                    handler.hydrate_span(to_wrap, wrapped, instance, args, kwargs, None, span, parent_span, ex,
+                                is_post_exec=False)
+                except Exception as e:
+                    logger.info(f"Warning: Error occurred in hydrate_span pre_process_span: {e}")
+                try:
+                    with monocle_trace_scope(get_builtin_scope_names(to_wrap)):
+                        async for item in amonocle_iter_wrapper_span_processor(tracer, handler, to_wrap, wrapped, instance, source_path, False, args, kwargs):
+                            last_item = item
+                            yield item
                 except Exception as e:
                     ex = e
                     raise
                 finally:
-                    post_process_span(handler, to_wrap, wrapped, instance, args, kwargs, last_item, span, parent_span, ex)
+                    last_item = post_process_span(handler, to_wrap, wrapped, instance, args, kwargs, last_item, span, parent_span, ex)
             else:
                 try:
-                    with SpanHandler.workflow_type(to_wrap, span):
-                        async for item in wrapped(*args, **kwargs):
-                            last_item = item
-                            yield item
+                    handler.hydrate_span(to_wrap, wrapped, instance, args, kwargs, None, span, parent_span, ex,
+                                is_post_exec=False)
+                except Exception as e:
+                    logger.info(f"Warning: Error occurred in hydrate_span pre_process_span: {e}")
+                try:
+                    skip_execution, last_item = SpanHandler.skip_execution(span)
+                    if not skip_execution:
+                        with SpanHandler.workflow_type(to_wrap, span):
+                            async for item in wrapped(*args, **kwargs):
+                                last_item = item
+                                yield item
+                    else:
+                        yield last_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)
+                        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)
+                        last_item = post_process_span_internal(last_item)
     return
 
 async def amonocle_wrapper(tracer: Tracer, handler: SpanHandler, to_wrap, wrapped, instance, source_path, args, kwargs):
@@ -245,7 +301,9 @@ async def amonocle_wrapper(tracer: Tracer, handler: SpanHandler, to_wrap, wrappe
     pre_trace_token = None
     try:
         try:
-            pre_trace_token = handler.pre_tracing(to_wrap, wrapped, instance, args, kwargs)
+            pre_trace_token, alternate_to_wrapp = handler.pre_tracing(to_wrap, wrapped, instance, args, kwargs)
+            if alternate_to_wrapp is not None:
+                to_wrap = alternate_to_wrapp
         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):
@@ -271,7 +329,9 @@ async def amonocle_iter_wrapper(tracer: Tracer, handler: SpanHandler, to_wrap, w
     pre_trace_token = None
     try:
         try:
-            pre_trace_token = handler.pre_tracing(to_wrap, wrapped, instance, args, kwargs)
+            pre_trace_token, alternate_to_wrapp = handler.pre_tracing(to_wrap, wrapped, instance, args, kwargs)
+            if alternate_to_wrapp is not None:
+                to_wrap = alternate_to_wrapp
         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):
@@ -373,13 +433,14 @@ def evaluate_scope_values(args, kwargs, to_wrap, scope_values):
 @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.
+        This essentially 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:
@@ -391,18 +452,26 @@ def start_as_monocle_span(tracer: Tracer, name: str, auto_close_span: bool) -> I
     detach(monocle_span_token)
 
 def get_builtin_scope_names(to_wrap) -> str:
-    output_processor = to_wrap.get("output_processor", None)
-    span_type = output_processor.get("type", None) if output_processor else None
+    output_processor = None
+    if "output_processor" in to_wrap:
+        output_processor = to_wrap.get("output_processor", None)
+    if "output_processor_list" in to_wrap:
+        for processor in to_wrap["output_processor_list"]:
+            if processor.get("type", None) in AGENTIC_SPANS:
+                output_processor = processor
+                break
+
+    span_type = output_processor.get("type", None) if output_processor and isinstance(output_processor, dict) else None
     if span_type and span_type in AGENTIC_SPANS:
         return span_type
     return None
 
-def get_wrapper_with_next_processor(to_wrap, handler, instance, args, kwargs):
+def get_wrapper_with_next_processor(to_wrap, handler, instance, span, parent_span, args, kwargs):
     if has_more_processors(to_wrap):
         next_output_processor_list = to_wrap.get('output_processor_list',[]).copy()
         while len(next_output_processor_list) > 0:
             next_output_processor = next_output_processor_list.pop(0)
-            if handler.should_skip(next_output_processor, instance, args, kwargs):
+            if handler.should_skip(next_output_processor, instance, span, parent_span, args, kwargs):
                 next_output_processor = None
             else:
                 break
@@ -412,4 +481,4 @@ def get_wrapper_with_next_processor(to_wrap, handler, instance, args, kwargs):
     return to_wrap
 
 def has_more_processors(to_wrap) -> bool:
-    return len(to_wrap.get('output_processor_list', [])) > 0
+    return len(to_wrap.get('output_processor_list', [])) > 0

monocle_apptrace/instrumentation/common/wrapper_method.py

@@ -5,6 +5,7 @@ from monocle_apptrace.instrumentation.common.span_handler import SpanHandler, No
 from monocle_apptrace.instrumentation.metamodel.azureaiinference.methods import AZURE_AI_INFERENCE_METHODS
 from monocle_apptrace.instrumentation.metamodel.botocore.methods import BOTOCORE_METHODS
 from monocle_apptrace.instrumentation.metamodel.botocore.handlers.botocore_span_handler import BotoCoreSpanHandler
+from monocle_apptrace.instrumentation.metamodel.hugging_face.methods import HUGGING_FACE_METHODS
 from monocle_apptrace.instrumentation.metamodel.langchain.methods import (
     LANGCHAIN_METHODS,
 )
@@ -38,6 +39,7 @@ from monocle_apptrace.instrumentation.metamodel.a2a.methods import A2A_CLIENT_ME
 from monocle_apptrace.instrumentation.metamodel.litellm.methods import LITELLM_METHODS
 from monocle_apptrace.instrumentation.metamodel.adk.methods import ADK_METHODS
 from monocle_apptrace.instrumentation.metamodel.mistral.methods import MISTRAL_METHODS
+from monocle_apptrace.instrumentation.metamodel.strands.methods import STRAND_METHODS
 
 class WrapperMethod:
     def __init__(
@@ -109,7 +111,9 @@ DEFAULT_METHODS_LIST = (
     A2A_CLIENT_METHODS +
     LITELLM_METHODS +
     ADK_METHODS +
-    MISTRAL_METHODS
+    MISTRAL_METHODS +
+    HUGGING_FACE_METHODS +
+    STRAND_METHODS
 )
 
 MONOCLE_SPAN_HANDLERS: Dict[str, SpanHandler] = {
@@ -131,5 +135,5 @@ MONOCLE_SPAN_HANDLERS: Dict[str, SpanHandler] = {
     "llamaindex_tool_handler": LlamaIndexToolHandler(),
     "llamaindex_agent_handler": LlamaIndexAgentHandler(),
     "llamaindex_single_agent_tool_handler": LlamaIndexSingleAgenttToolHandlerWrapper(),
-    "lambda_func_handler": lambdaSpanHandler(),
+    "lambda_func_handler": lambdaSpanHandler()
 }

monocle_apptrace/instrumentation/metamodel/a2a/methods.py

@@ -11,7 +11,7 @@ A2A_CLIENT_METHODS = [
     #     "output_processor": A2A_RESOLVE,
     # },
     {
-        "package": "a2a.client.client",
+        "package": "a2a.client",
         "object": "A2AClient",
         "method": "send_message",
         "wrapper_method": atask_wrapper,

monocle_apptrace/instrumentation/metamodel/adk/_helper.py

@@ -4,6 +4,7 @@ This module provides utility functions to extract various attributes from agent
 """
 
 from ast import arguments
+import json
 from typing import Any, Dict, Optional
 from monocle_apptrace.instrumentation.metamodel.finish_types import map_adk_finish_reason_to_finish_type
 
@@ -82,7 +83,7 @@ def extract_agent_input(arguments: Dict[str, Any]) -> Any:
     Returns:
         Any: The extracted input data
     """
-    return arguments['args'][0].user_content.parts[0].text
+    return [arguments['args'][0].user_content.parts[0].text]
 
 def extract_agent_request_input(arguments: Dict[str, Any]) -> Any:
     """
@@ -94,7 +95,7 @@ def extract_agent_request_input(arguments: Dict[str, Any]) -> Any:
     Returns:
         Any: The extracted input data
     """
-    return arguments['kwargs']['new_message'].parts[0].text if 'new_message' in arguments['kwargs'] else None
+    return [arguments['kwargs']['new_message'].parts[0].text] if 'new_message' in arguments['kwargs'] else []
 
 def extract_agent_response(result: Any) -> Any:
     """
@@ -107,7 +108,9 @@ def extract_agent_response(result: Any) -> Any:
         Any: The extracted response data
     """
     if result:
-        return result.content.parts[0].text
+        return str(result.content.parts[0].text)
+    else:
+        return ""
 
 def get_tool_name(instance: Any) -> str:
     """
@@ -179,7 +182,7 @@ def extract_tool_input(arguments: Dict[str, Any]) -> Any:
     Returns:
         Any: The extracted input data
     """
-    return str(arguments['kwargs'].get('args'))
+    return json.dumps(arguments['kwargs'].get('args', {}))
 
 def extract_tool_response(result: Any) -> Any:
     """

monocle_apptrace/instrumentation/metamodel/adk/entities/agent.py

@@ -1,6 +1,7 @@
 from monocle_apptrace.instrumentation.common.constants import SPAN_SUBTYPES, SPAN_TYPES
 from monocle_apptrace.instrumentation.common.utils import get_error_message
 from monocle_apptrace.instrumentation.metamodel.adk import _helper
+from monocle_apptrace.instrumentation.common.utils import get_error_message
 AGENT = {
       "type": SPAN_TYPES.AGENTIC_INVOCATION,
       "subtype": SPAN_SUBTYPES.ROUTING,
@@ -34,7 +35,7 @@ AGENT = {
           "attributes": [
             {
                 "_comment": "this is Agent input",
-                "attribute": "query",
+                "attribute": "input",
                 "accessor": lambda arguments: _helper.extract_agent_input(arguments)
             }
           ]
@@ -42,6 +43,10 @@ AGENT = {
         {
           "name":"data.output",
           "attributes": [
+            {
+                    "attribute": "error_code",
+                    "accessor": lambda arguments: get_error_message(arguments)
+            },
             {
                 "_comment": "this is response from LLM",
                 "attribute": "response",

monocle_apptrace/instrumentation/metamodel/agents/_helper.py

@@ -50,21 +50,21 @@ def extract_agent_input(arguments):
         if len(arguments["args"]) > 1:
             input_data = arguments["args"][1]
             if isinstance(input_data, str):
-                return input_data
+                return [input_data]
             elif isinstance(input_data, list):
                 # Handle list of input items
-                return get_json_dumps(input_data)
+                return input_data
 
         # Fallback to kwargs
         if "original_input" in arguments["kwargs"]:
             input_data = arguments["kwargs"]["original_input"]
             if isinstance(input_data, str):
-                return input_data
+                return [input_data]
             elif isinstance(input_data, list):
-                return get_json_dumps(input_data)
+                return input_data
     except Exception as e:
         logger.warning("Warning: Error occurred in extract_agent_input: %s", str(e))
-    return None
+    return []
 
 
 def get_agent_name(arguments) -> str:
@@ -134,12 +134,12 @@ def extract_tool_input(arguments):
                 1
             ]  # Second argument is usually the JSON string with params
             if isinstance(tool_input, str):
-                return [tool_input]
+                return tool_input
             elif isinstance(tool_input, dict):
-                return [get_json_dumps(tool_input)]
+                return get_json_dumps(tool_input)
 
         # Fallback to all args
-        return [str(arg) for arg in arguments["args"]]
+        return str(arguments["args"])
     except Exception as e:
         logger.warning("Warning: Error occurred in extract_tool_input: %s", str(e))
     return []

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

@@ -1,6 +1,7 @@
 from monocle_apptrace.instrumentation.common.constants import AGENT_REQUEST_SPAN_NAME, SPAN_SUBTYPES, SPAN_TYPES
 from monocle_apptrace.instrumentation.common.utils import get_error_message
 from monocle_apptrace.instrumentation.metamodel.agents import _helper
+from monocle_apptrace.instrumentation.common.utils import get_error_message
 
 AGENT = {
     "type": SPAN_TYPES.AGENTIC_INVOCATION,
@@ -35,7 +36,7 @@ AGENT = {
             "attributes": [
                 {
                     "_comment": "this is Agent input",
-                    "attribute": "query",
+                    "attribute": "input",
                     "accessor": lambda arguments: _helper.extract_agent_input(
                         arguments
                     ),
@@ -45,6 +46,10 @@ AGENT = {
         {
             "name": "data.output",
             "attributes": [
+                {
+                    "attribute": "error_code",
+                    "accessor": lambda arguments: get_error_message(arguments)
+                },
                 {
                     "_comment": "this is response from Agent",
                     "attribute": "response",
@@ -73,7 +78,7 @@ AGENT = {
 }
 
 AGENT_REQUEST = {
-    "type": AGENT_REQUEST_SPAN_NAME,
+    "type": SPAN_TYPES.AGENTIC_REQUEST,
     "subtype": SPAN_SUBTYPES.PLANNING,
     "attributes": [
         [
@@ -123,6 +128,7 @@ TOOLS = {
             {
                 "_comment": "tool type",
                 "attribute": "type",
+                "phase": "post_execution",
                 "accessor": lambda arguments: _helper.get_tool_type(arguments["span"]),
             },
             {
@@ -201,6 +207,7 @@ AGENT_DELEGATION = {
             {
                 "_comment": "name of the target agent",
                 "attribute": "to_agent",
+                "phase": "post_execution",
                 "accessor": lambda arguments: _helper.extract_handoff_target(arguments),
             },
         ]

monocle_apptrace/instrumentation/metamodel/aiohttp/_helper.py

@@ -67,7 +67,7 @@ def get_function_name(args) -> str:
 class aiohttpSpanHandler(SpanHandler):
 
     def pre_tracing(self, to_wrap, wrapped, instance, args, kwargs):
-        return aiohttp_pre_tracing(args)
+        return aiohttp_pre_tracing(args), None
     
     def post_tracing(self, to_wrap, wrapped, instance, args, kwargs, return_value, token):
         aiohttp_post_tracing(token)

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

@@ -6,6 +6,7 @@ from monocle_apptrace.instrumentation.common.utils import (get_error_message, re
 
 INFERENCE = {
     "type": SPAN_TYPES.INFERENCE,
+    "subtype": lambda arguments: _helper.agent_inference_type(arguments),
     "attributes": [
         [
             {
@@ -80,10 +81,6 @@ INFERENCE = {
                     "_comment": "finish type mapped from finish reason",
                     "attribute": "finish_type",
                     "accessor": lambda arguments: _helper.map_finish_reason_to_finish_type(_helper.extract_finish_reason(arguments))
-                },
-                {
-                    "attribute": "inference_sub_type",
-                    "accessor": lambda arguments: _helper.agent_inference_type(arguments)
                 }
             ]
         }

monocle_apptrace/instrumentation/metamodel/azfunc/_helper.py

@@ -84,7 +84,7 @@ def azure_func_post_tracing(token):
 class azureSpanHandler(SpanHandler):
 
     def pre_tracing(self, to_wrap, wrapped, instance, args, kwargs):
-        return azure_func_pre_tracing(kwargs)
+        return azure_func_pre_tracing(kwargs), None
     
     def post_tracing(self, to_wrap, wrapped, instance, args, kwargs, return_value, token):
         azure_func_post_tracing(token)

monocle_apptrace/instrumentation/metamodel/botocore/_helper.py

@@ -7,6 +7,8 @@ import logging
 import json
 from io import BytesIO
 from functools import wraps
+
+from rfc3986 import urlparse
 from monocle_apptrace.instrumentation.common.span_handler import SpanHandler
 from monocle_apptrace.instrumentation.common.utils import ( get_exception_message, get_json_dumps, get_status_code,)
 from monocle_apptrace.instrumentation.metamodel.finish_types import map_bedrock_finish_reason_to_finish_type
@@ -194,3 +196,6 @@ def extract_finish_reason(arguments):
 def map_finish_reason_to_finish_type(finish_reason):
     """Map Bedrock finish_reason/stopReason to finish_type."""
     return map_bedrock_finish_reason_to_finish_type(finish_reason)
+
+def extract_provider_name(instance):
+    return urlparse(instance.meta.endpoint_url).hostname

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

@@ -15,6 +15,10 @@ INFERENCE = {
             {
                 "attribute": "inference_endpoint",
                 "accessor": lambda arguments: arguments['instance'].meta.endpoint_url
+            },
+            {
+                "attribute": "provider_name",
+                "accessor": lambda arguments: _helper.extract_provider_name(arguments['instance'])
             }
         ],
         [

monocle_apptrace/instrumentation/metamodel/fastapi/_helper.py

@@ -77,12 +77,12 @@ class FastAPISpanHandler(SpanHandler):
         fastapi_pre_tracing(scope)
         return super().pre_tracing(to_wrap, wrapped, instance, args, kwargs)
 
-    def post_tracing(self, to_wrap, wrapped, instance, args, kwargs, return_value):
+    def post_tracing(self, to_wrap, wrapped, instance, args, kwargs, return_value, token):
         fastapi_post_tracing()
-        return super().post_tracing(to_wrap, wrapped, instance, args, kwargs, return_value)
+        return super().post_tracing(to_wrap, wrapped, instance, args, kwargs, return_value, token)
 
 class FastAPIResponseSpanHandler(SpanHandler):
-    def post_tracing(self, to_wrap, wrapped, instance, args, kwargs, return_value):
+    def post_tracing(self, to_wrap, wrapped, instance, args, kwargs, return_value, token):
         try:
             ctx = get_current()
             if ctx is not None:
@@ -92,4 +92,4 @@ class FastAPIResponseSpanHandler(SpanHandler):
                                         return_value, parent_span=parent_span)
         except Exception as e:
             logger.info(f"Failed to propagate fastapi response: {e}")
-        super().post_tracing(to_wrap, wrapped, instance, args, kwargs, return_value)
+        super().post_tracing(to_wrap, wrapped, instance, args, kwargs, return_value, token)

monocle_apptrace/instrumentation/metamodel/fastapi/methods.py

@@ -3,10 +3,10 @@ from monocle_apptrace.instrumentation.metamodel.fastapi.entities.http import FAS
 
 FASTAPI_METHODS = [
     {
-        "package": "fastapi",
-        "object": "FastAPI",
-        "method": "__call__",
-        "wrapper_method": task_wrapper,
+        "package": "fastapi.routing",
+        "object": "APIRoute",
+        "method": "handle",
+        "wrapper_method": atask_wrapper,
         "span_name": "fastapi.request",
         "span_handler": "fastapi_handler",
         "output_processor": FASTAPI_HTTP_PROCESSOR,