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

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

@@ -0,0 +1,191 @@
+from monocle_apptrace.instrumentation.metamodel.agents import _helper
+
+AGENT = {
+    "type": "agentic.invocation",
+    "attributes": [
+        [
+            {
+                "_comment": "agent type",
+                "attribute": "type",
+                "accessor": lambda arguments: _helper.AGENTS_AGENT_NAME_KEY,
+            },
+            {
+                "_comment": "name of the agent",
+                "attribute": "name",
+                "accessor": lambda arguments: _helper.get_agent_name(arguments),
+            },
+            {
+                "_comment": "agent description",
+                "attribute": "description",
+                "accessor": lambda arguments: _helper.get_agent_description(arguments),
+            },
+            {
+                "_comment": "agent instructions",
+                "attribute": "instructions",
+                "accessor": lambda arguments: _helper.get_agent_instructions(arguments),
+            },
+        ]
+    ],
+    "events": [
+        {
+            "name": "data.input",
+            "attributes": [
+                {
+                    "_comment": "this is Agent input",
+                    "attribute": "query",
+                    "accessor": lambda arguments: _helper.extract_agent_input(
+                        arguments
+                    ),
+                }
+            ],
+        },
+        {
+            "name": "data.output",
+            "attributes": [
+                {
+                    "_comment": "this is response from Agent",
+                    "attribute": "response",
+                    "accessor": lambda arguments: _helper.extract_agent_response(
+                        arguments["result"]
+                    ),
+                }
+            ],
+        },
+        {
+            "name": "metadata",
+            "attributes": [
+                {
+                    "_comment": "this is metadata from Agent response",
+                    "accessor": lambda arguments: _helper.update_span_from_agent_response(
+                        arguments["result"]
+                    ),
+                }
+            ],
+        },
+    ],
+}
+
+AGENT_REQUEST = {
+    "type": "agentic.request",
+    "attributes": [
+        [
+            {
+                "_comment": "agent type",
+                "attribute": "type",
+                "accessor": lambda arguments: _helper.AGENTS_AGENT_NAME_KEY,
+            }
+        ],
+    ],
+    "events": [
+        {
+            "name": "data.input",
+            "attributes": [
+                {
+                    "_comment": "this is Agent input",
+                    "attribute": "input",
+                    "accessor": lambda arguments: _helper.extract_agent_input(
+                        arguments
+                    ),
+                }
+            ],
+        },
+        {
+            "name": "data.output",
+            "attributes": [
+                {
+                    "_comment": "this is response from Agent",
+                    "attribute": "response",
+                    "accessor": lambda arguments: _helper.extract_agent_response(
+                        arguments["result"]
+                    ),
+                }
+            ],
+        },
+    ],
+}
+
+TOOLS = {
+    "type": "agentic.tool.invocation",
+    "attributes": [
+        [
+            {
+                "_comment": "tool type",
+                "attribute": "type",
+                "accessor": lambda arguments: "tool.openai_agents",
+            },
+            {
+                "_comment": "name of the tool",
+                "attribute": "name",
+                "accessor": lambda arguments: _helper.get_tool_name(
+                    arguments["instance"]
+                ),
+            },
+            {
+                "_comment": "tool description",
+                "attribute": "description",
+                "accessor": lambda arguments: _helper.get_tool_description(
+                    arguments["instance"]
+                ),
+            },
+        ],
+        [
+            {
+                "_comment": "name of the agent",
+                "attribute": "name",
+                "accessor": lambda arguments: _helper.get_source_agent(),
+            },
+            {
+                "_comment": "agent type",
+                "attribute": "type",
+                "accessor": lambda arguments: _helper.AGENTS_AGENT_NAME_KEY,
+            },
+        ],
+    ],
+    "events": [
+        {
+            "name": "data.input",
+            "attributes": [
+                {
+                    "_comment": "this is Tool input",
+                    "attribute": "Inputs",
+                    "accessor": lambda arguments: _helper.extract_tool_input(arguments),
+                },
+            ],
+        },
+        {
+            "name": "data.output",
+            "attributes": [
+                {
+                    "_comment": "this is response from Tool",
+                    "attribute": "response",
+                    "accessor": lambda arguments: _helper.extract_tool_response(
+                        arguments["result"]
+                    ),
+                }
+            ],
+        },
+    ],
+}
+
+AGENT_DELEGATION = {
+    "type": "agentic.delegation",
+    "attributes": [
+        [
+            {
+                "_comment": "agent type",
+                "attribute": "type",
+                "accessor": lambda arguments: _helper.AGENTS_AGENT_NAME_KEY,
+            },
+            {
+                "_comment": "name of the source agent",
+                "attribute": "from_agent",
+                "accessor": lambda arguments: _helper.get_source_agent(),
+            },
+            {
+                "_comment": "name of the target agent",
+                "attribute": "to_agent",
+                "accessor": lambda arguments: _helper.extract_handoff_target(arguments),
+            },
+        ]
+    ],
+}

monocle_apptrace/instrumentation/metamodel/agents/methods.py

@@ -0,0 +1,56 @@
+from monocle_apptrace.instrumentation.common.wrapper import task_wrapper, atask_wrapper
+from monocle_apptrace.instrumentation.metamodel.agents.entities.inference import (
+    AGENT,
+    AGENT_DELEGATION,
+    TOOLS,
+)
+from monocle_apptrace.instrumentation.metamodel.agents.agents_processor import (
+    constructor_wrapper,
+    handoff_constructor_wrapper,
+)
+
+AGENTS_METHODS = [
+    # Main agent runner methods
+    {
+        "package": "agents.run",
+        "object": "Runner",
+        "method": "run",
+        "wrapper_method": atask_wrapper,
+        "span_handler": "agents_agent_handler",
+        "output_processor": AGENT,
+    },
+    {
+        "package": "agents.run",
+        "object": "Runner",
+        "method": "run_sync",
+        "wrapper_method": task_wrapper,
+        "span_handler": "agents_agent_handler",
+        "output_processor": AGENT,
+    },
+    # AgentRunner class methods (internal runner)
+    {
+        "package": "agents.run",
+        "object": "AgentRunner",
+        "method": "_run_single_turn",
+        "wrapper_method": atask_wrapper,
+        "span_handler": "agents_agent_handler",
+        "output_processor": AGENT,
+    },
+    # Function tool decorator - wrap the function_tool function directly
+    {
+        "package": "agents.tool",
+        "object": "FunctionTool",
+        "method": "__init__",  # Empty string means wrap the function itself
+        "wrapper_method": constructor_wrapper,
+        "span_handler": "agents_tool_handler",
+        "output_processor": TOOLS,
+    },
+    {
+        "package": "agents.handoffs",
+        "object": "Handoff",
+        "method": "__init__",  # Empty string means wrap the function itself
+        "wrapper_method": handoff_constructor_wrapper,
+        "span_handler": "agents_tool_handler",
+        "output_processor": AGENT_DELEGATION,
+    },
+]

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,20 @@ This module provides utility functions for extracting system, user,
 and assistant messages from various input formats.
 """
 
+import json
 import logging
+from opentelemetry.context import get_value
 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
+from monocle_apptrace.instrumentation.common.constants import AGENT_PREFIX_KEY, INFERENCE_AGENT_DELEGATION, INFERENCE_COMMUNICATION, INFERENCE_TOOL_CALL
 
 
 logger = logging.getLogger(__name__)
@@ -30,12 +36,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 +55,55 @@ 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"
+            
+            # Handle tool use content blocks
+            if hasattr(response, "content") and response.content:
+                tools = []
+                text_content = []
+                
+                for content_block in response.content:
+                    if hasattr(content_block, "type"):
+                        if content_block.type == "tool_use":
+                            # Extract tool use information
+                            tool_info = {
+                                "tool_id": getattr(content_block, "id", ""),
+                                "tool_name": getattr(content_block, "name", ""),
+                                "tool_arguments": getattr(content_block, "input", "")
+                            }
+                            tools.append(tool_info)
+                        elif content_block.type == "text":
+                            # Extract text content
+                            if hasattr(content_block, "text"):
+                                text_content.append(content_block.text)
+                
+                # If we have tools, add them to the message
+                if tools:
+                    messages.append({"tools": tools})
+                
+                # If we have text content, add it to the message
+                if text_content:
+                    messages.append({role: " ".join(text_content)})
+                
+                # Fallback to original logic if no content blocks were processed
+                if not messages 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 +120,64 @@ 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)
+
+def agent_inference_type(arguments):
+    """Extract agent inference type from Anthropic response"""
+    try:
+        status = get_status_code(arguments)
+        if status == 'success' or status == 'completed':
+            response = arguments["result"]
+            
+            # Check if stop_reason indicates tool use
+            if hasattr(response, "stop_reason") and response.stop_reason == "tool_use":
+                # Check if this is agent delegation by looking at tool names
+                if hasattr(response, "content") and response.content:
+                    agent_prefix = get_value(AGENT_PREFIX_KEY)
+                    for content_block in response.content:
+                        if (hasattr(content_block, "type") and 
+                            content_block.type == "tool_use" and
+                            hasattr(content_block, "name")):
+                            tool_name = content_block.name
+                            if agent_prefix and tool_name.startswith(agent_prefix):
+                                return INFERENCE_AGENT_DELEGATION
+                    # If we found tool use but no agent delegation, it's a regular tool call
+                    return INFERENCE_TOOL_CALL
+            
+            # Fallback: check the extracted message for tool content
+            assistant_message = extract_assistant_message(arguments)
+            if assistant_message:
+                try:
+                    message = json.loads(assistant_message)
+                    if message and isinstance(message, dict):
+                        assistant_content = message.get("assistant", "")
+                        if assistant_content:
+                            agent_prefix = get_value(AGENT_PREFIX_KEY)
+                            if agent_prefix and agent_prefix in assistant_content:
+                                return INFERENCE_AGENT_DELEGATION
+                except (json.JSONDecodeError, TypeError):
+                    # If JSON parsing fails, fall back to string analysis
+                    agent_prefix = get_value(AGENT_PREFIX_KEY)
+                    if agent_prefix and agent_prefix in assistant_message:
+                        return INFERENCE_AGENT_DELEGATION
+        
+        return INFERENCE_COMMUNICATION
+    except Exception as e:
+        logger.warning("Warning: Error occurred in agent_inference_type: %s", str(e))
+        return INFERENCE_COMMUNICATION

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,20 @@ 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))
+                },
+                {
+                    "attribute": "inference_sub_type",
+                    "accessor": lambda arguments: _helper.agent_inference_type(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": [