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

monocle_apptrace/instrumentation/common/wrapper.py

@@ -5,7 +5,6 @@ from opentelemetry.context import set_value, attach, detach, get_value
 
 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,
@@ -36,7 +35,7 @@ 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:
             handler.hydrate_span(to_wrap, wrapped, instance, args, kwargs, return_value, span, parent_span, ex)
@@ -44,7 +43,7 @@ def post_process_span(handler, to_wrap, wrapped, instance, args, kwargs, return_
             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 +51,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):
@@ -93,10 +92,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,7 +111,7 @@ 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}")
 
@@ -141,7 +141,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"):
@@ -154,9 +154,10 @@ async def amonocle_wrapper_span_processor(tracer: Tracer, handler: SpanHandler,
 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):
@@ -171,7 +172,7 @@ async def amonocle_wrapper(tracer: Tracer, handler: SpanHandler, to_wrap, wrappe
         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}")
 

monocle_apptrace/instrumentation/common/wrapper_method.py

@@ -9,10 +9,12 @@ 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.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 +25,15 @@ 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
+
 class WrapperMethod:
     def __init__(
             self,
@@ -71,7 +82,26 @@ 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 + 
+    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
+)
 
 MONOCLE_SPAN_HANDLERS: Dict[str, SpanHandler] = {
     "default": SpanHandler(),
@@ -83,4 +113,13 @@ 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(),
+    "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,
+    },
+]
+
+

monocle_apptrace/instrumentation/metamodel/aiohttp/_helper.py

@@ -7,8 +7,6 @@ from urllib.parse import unquote
 
 logger = logging.getLogger(__name__)
 MAX_DATA_LENGTH = 1000
-token_data = local()
-token_data.current_token = None
 
 def get_route(args) -> str:
     route_path: Option[str] = try_option(getattr, args[0], 'path')
@@ -41,11 +39,10 @@ def extract_status(result) -> str:
     return status
 
 def aiohttp_pre_tracing(args):
-    token_data.current_token = extract_http_headers(args[0].headers)
+    return extract_http_headers(args[0].headers)
 
-def aiohttp_post_tracing():
-    clear_http_scopes(token_data.current_token)
-    token_data.current_token = None
+def aiohttp_post_tracing(token):
+    clear_http_scopes(token)
 
 def aiohttp_skip_span(args) -> bool:
     if get_method(args) == "HEAD":
@@ -55,12 +52,10 @@ def aiohttp_skip_span(args) -> bool:
 class aiohttpSpanHandler(SpanHandler):
 
     def pre_tracing(self, to_wrap, wrapped, instance, args, kwargs):
-        aiohttp_pre_tracing(args)
-        return super().pre_tracing(to_wrap, wrapped, instance, args, kwargs)
+        return aiohttp_pre_tracing(args)
     
-    def post_tracing(self, to_wrap, wrapped, instance, args, kwargs, return_value):
-        aiohttp_post_tracing()
-        return super().post_tracing(to_wrap, wrapped, instance, args, kwargs, return_value)
+    def post_tracing(self, to_wrap, wrapped, instance, args, kwargs, return_value, token):
+        aiohttp_post_tracing(token)
 
     def skip_span(self, to_wrap, wrapped, instance, args, kwargs) -> bool:
         return aiohttp_skip_span(args)

monocle_apptrace/instrumentation/metamodel/anthropic/_helper.py

@@ -3,14 +3,18 @@ This module provides utility functions for extracting system, user,
 and assistant messages from various input formats.
 """
 
+import json
 import logging
 from monocle_apptrace.instrumentation.common.utils import (
     Option,
+    get_json_dumps,
     get_keys_as_tuple,
     get_nested_value,
+    get_status_code,
     try_option,
     get_exception_message,
 )
+from monocle_apptrace.instrumentation.metamodel.finish_types import map_anthropic_finish_reason_to_finish_type
 
 
 logger = logging.getLogger(__name__)
@@ -30,12 +34,13 @@ def extract_messages(kwargs):
     """Extract system and user messages"""
     try:
         messages = []
+        if "system" in kwargs and isinstance(kwargs["system"], str):
+            messages.append({"system": kwargs["system"]})
         if 'messages' in kwargs and len(kwargs['messages']) >0:
             for msg in kwargs['messages']:
                 if msg.get('content') and msg.get('role'):
                     messages.append({msg['role']: msg['content']})
-
-        return [str(message) for message in messages]
+        return [get_json_dumps(message) for message in messages]
     except Exception as e:
         logger.warning("Warning: Error occurred in extract_messages: %s", str(e))
         return []
@@ -48,28 +53,24 @@ def get_exception_status_code(arguments):
     else:
         return 'success'
 
-def get_status_code(arguments):
-    if arguments["exception"] is not None:
-        return get_exception_status_code(arguments)
-    elif hasattr(arguments["result"], "status"):
-        return arguments["result"].status
-    else:
-        return 'success'
-
 def extract_assistant_message(arguments):
     try:
         status = get_status_code(arguments)
-        response: str = ""
+        response = arguments["result"]
         if status == 'success':
-            if arguments['result'] is not None and hasattr(arguments['result'],"content") and len(arguments['result'].content) >0:
-                if hasattr(arguments['result'].content[0],"text"):
-                    response = arguments['result'].content[0].text
+            messages = []
+            role = response.role if hasattr(response, 'role') else "assistant"
+            if response is not None and hasattr(response,"content") and len(response.content) >0:
+                if hasattr(response.content[0],"text"):
+                    messages.append({role: response.content[0].text})
+            # return first message if list is not empty
+            return get_json_dumps(messages[0]) if messages else ""
         else:
             if arguments["exception"] is not None:
-                response = get_exception_message(arguments)
+                return get_exception_message(arguments)
             elif hasattr(arguments["result"], "error"):
-                response = arguments["result"].error
-        return response
+                return arguments["result"].error
+
     except (IndexError, AttributeError) as e:
         logger.warning("Warning: Error occurred in extract_assistant_message: %s", str(e))
         return None
@@ -86,4 +87,20 @@ def update_span_from_llm_response(response):
             meta_dict.update({"completion_tokens": getattr(response.usage, "output_tokens", 0)})
             meta_dict.update({"prompt_tokens": getattr(response.usage, "input_tokens", 0)})
             meta_dict.update({"total_tokens": getattr(response.usage, "input_tokens", 0)+getattr(response.usage, "output_tokens", 0)})
-    return meta_dict
+    return meta_dict
+
+def extract_finish_reason(arguments):
+    """Extract stop_reason from Anthropic response (Claude)."""
+    try:
+        # Arguments may be a dict with 'result' or just the response object
+        response = arguments.get("result") if isinstance(arguments, dict) else arguments
+        if response is not None and hasattr(response, "stop_reason"):
+            return response.stop_reason
+    except Exception as e:
+        logger.warning("Warning: Error occurred in extract_finish_reason: %s", str(e))
+        return None
+    return None
+
+def map_finish_reason_to_finish_type(finish_reason):
+    """Map Anthropic stop_reason to finish_type, similar to OpenAI mapping."""
+    return map_anthropic_finish_reason_to_finish_type(finish_reason)

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

@@ -1,9 +1,7 @@
 from monocle_apptrace.instrumentation.metamodel.anthropic import (
     _helper,
 )
-from monocle_apptrace.instrumentation.common.utils import (resolve_from_alias, get_llm_type,
-    get_status, get_status_code
-)
+from monocle_apptrace.instrumentation.common.utils import (get_error_message, resolve_from_alias)
 
 INFERENCE = {
     "type": "inference",
@@ -12,7 +10,7 @@ INFERENCE = {
             {
                 "_comment": "provider type ,name , deployment , inference_endpoint",
                 "attribute": "type",
-                "accessor": lambda arguments: 'inference.' + (get_llm_type(arguments['instance']) or 'generic')
+                "accessor": lambda arguments: 'inference.anthropic'
 
             },
             {
@@ -55,12 +53,8 @@ INFERENCE = {
             "name": "data.output",
             "attributes": [
                 {
-                    "attribute": "status",
-                    "accessor": lambda arguments: get_status(arguments)
-                },
-                {
-                    "attribute": "status_code",
-                    "accessor": lambda arguments: _helper.get_status_code(arguments)
+                    "attribute": "error_code",
+                    "accessor": lambda arguments: get_error_message(arguments)
                 },
                 {
                     "_comment": "this is result from LLM",
@@ -75,6 +69,16 @@ INFERENCE = {
                 {
                     "_comment": "this is metadata usage from LLM",
                     "accessor": lambda arguments: _helper.update_span_from_llm_response(arguments['result'])
+                },
+                {
+                    "_comment": "finish reason from Anthropic response",
+                    "attribute": "finish_reason",
+                    "accessor": lambda arguments: _helper.extract_finish_reason(arguments)
+                },
+                {
+                    "_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))
                 }
             ]
         }

monocle_apptrace/instrumentation/metamodel/azfunc/_helper.py

@@ -8,8 +8,6 @@ from urllib.parse import unquote, urlparse, ParseResult
 
 logger = logging.getLogger(__name__)
 MAX_DATA_LENGTH = 1000
-token_data = local()
-token_data.current_token = None
 
 def get_url(kwargs) -> ParseResult:
     url_str = try_option(getattr, kwargs['req'], 'url')
@@ -19,6 +17,13 @@ def get_url(kwargs) -> ParseResult:
     else:
         return None
 
+def get_function_name(kwargs) -> str:
+    context = kwargs.get('context', None)
+    if context is not None and hasattr(context, 'function_name'):
+        return context.function_name
+    return ""
+    
+
 def get_route(kwargs) -> str:
     url:ParseResult = get_url(kwargs)
     if url is not None:
@@ -61,18 +66,15 @@ def extract_status(result) -> str:
 
 def azure_func_pre_tracing(kwargs):
     headers = kwargs['req'].headers if hasattr(kwargs['req'], 'headers') else {}
-    token_data.current_token = extract_http_headers(headers)
+    return extract_http_headers(headers)
 
-def azure_func_post_tracing():
-    clear_http_scopes(token_data.current_token)
-    token_data.current_token = None
+def azure_func_post_tracing(token):
+    clear_http_scopes(token)
 
 class azureSpanHandler(SpanHandler):
 
     def pre_tracing(self, to_wrap, wrapped, instance, args, kwargs):
-        azure_func_pre_tracing(kwargs)
-        return super().pre_tracing(to_wrap, wrapped, instance, args, kwargs)
+        return azure_func_pre_tracing(kwargs)
     
-    def post_tracing(self, to_wrap, wrapped, instance, args, kwargs, return_value):
-        azure_func_post_tracing()
-        return super().post_tracing(to_wrap, wrapped, instance, args, kwargs, return_value)
+    def post_tracing(self, to_wrap, wrapped, instance, args, kwargs, return_value, token):
+        azure_func_post_tracing(token)

monocle_apptrace/instrumentation/metamodel/azfunc/entities/http.py

@@ -18,6 +18,11 @@ AZFUNC_HTTP_PROCESSOR = {
                 "attribute": "body",
                 "accessor": lambda arguments: _helper.get_body(arguments['kwargs'])
             },
+            {
+                "_comment": "request function name",
+                "attribute": "function_name",
+                "accessor": lambda arguments: _helper.get_function_name(arguments['kwargs'])
+            }
         ]
     ],
     "events": [