monocle-apptrace 0.4.0b2__py3-none-any.whl → 0.4.1__py3-none-any.whl

monocle_apptrace/instrumentation/metamodel/langchain/_helper.py

@@ -9,6 +9,8 @@ from monocle_apptrace.instrumentation.common.utils import (
     get_keys_as_tuple,
     get_nested_value,
     try_option,
+    get_exception_message,
+    get_status_code,
 )
 
 
@@ -35,18 +37,23 @@ def extract_messages(args):
         logger.warning("Warning: Error occurred in extract_messages: %s", str(e))
         return []
 
+def extract_assistant_message(arguments):
+    status = get_status_code(arguments)
+    response: str = ""
+    if status == 'success':
+        if isinstance(arguments['result'], str):
+            response = arguments['result']
+        if hasattr(arguments['result'], "content"):
+            response = arguments['result'].content
+        if hasattr(arguments['result'], "message") and hasattr(arguments['result'].message, "content"):
+            response =  arguments['result'].message.content
+    else:
+        if arguments["exception"] is not None:
+            response = get_exception_message(arguments)
+        elif hasattr(arguments["result"], "error"):
+            response = arguments["result"].error
 
-def extract_assistant_message(response):
-    try:
-        if isinstance(response, str):
-            return [response]
-        if hasattr(response, "content"):
-            return [response.content]
-        if hasattr(response, "message") and hasattr(response.message, "content"):
-            return [response.message.content]
-    except Exception as e:
-        logger.warning("Warning: Error occurred in extract_assistant_message: %s", str(e))
-        return []
+    return response
 
 
 def extract_provider_name(instance):
@@ -131,5 +138,4 @@ def update_span_from_llm_response(response, instance):
                 {"completion_tokens": token_usage.get("completion_tokens") or token_usage.get("output_tokens")})
             meta_dict.update({"prompt_tokens": token_usage.get("prompt_tokens") or token_usage.get("input_tokens")})
             meta_dict.update({"total_tokens": token_usage.get("total_tokens")})
-    return meta_dict
-
+    return meta_dict

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

@@ -1,7 +1,7 @@
 from monocle_apptrace.instrumentation.metamodel.langchain import (
     _helper,
 )
-from monocle_apptrace.instrumentation.common.utils import resolve_from_alias, get_llm_type
+from monocle_apptrace.instrumentation.common.utils import resolve_from_alias, get_llm_type, get_status, get_status_code
 
 INFERENCE = {
     "type": "inference.framework",
@@ -54,8 +54,16 @@ INFERENCE = {
             "attributes": [
                 {
                     "_comment": "this is result from LLM",
+                    "attribute": "status",
+                    "accessor": lambda arguments: get_status(arguments)
+                },
+                {
+                    "attribute": "status_code",
+                    "accessor": lambda arguments: get_status_code(arguments)
+                },
+                {
                     "attribute": "response",
-                    "accessor": lambda arguments: _helper.extract_assistant_message(arguments['result'])
+                    "accessor": lambda arguments: _helper.extract_assistant_message(arguments)
                 }
             ]
         },

monocle_apptrace/instrumentation/metamodel/llamaindex/_helper.py

@@ -11,6 +11,8 @@ from monocle_apptrace.instrumentation.common.utils import (
     get_keys_as_tuple,
     get_nested_value,
     try_option,
+    get_exception_message,
+    get_status_code,
 )
 
 logger = logging.getLogger(__name__)
@@ -60,19 +62,25 @@ def extract_messages(args):
         logger.warning("Error in extract_messages: %s", str(e))
         return []
 
-def extract_assistant_message(response):
-    try:
-        if isinstance(response, str):
-            return [response]
-        if hasattr(response, "content"):
-            return [response.content]
-        if hasattr(response, "message") and hasattr(response.message, "content"):
-            return [response.message.content]
-        if hasattr(response,"response") and isinstance(response.response, str):
-            return [response.response]
-    except Exception as e:
-        logger.warning("Warning: Error occurred in extract_assistant_message: %s", str(e))
-        return []
+def extract_assistant_message(arguments):
+    status = get_status_code(arguments)
+    response: str = ""
+    if status == 'success':
+        if isinstance(arguments['result'], str):
+            response = arguments['result']
+        if hasattr(arguments['result'], "content"):
+            response = arguments['result'].content
+        if hasattr(arguments['result'], "message") and hasattr(arguments['result'].message, "content"):
+            response = arguments['result'].message.content
+        if hasattr(arguments['result'],"response") and isinstance(arguments['result'].response, str):
+            response = arguments['result'].response
+    else:
+        if arguments["exception"] is not None:
+            response = get_exception_message(arguments)
+        elif hasattr(response, "error"):
+            response = arguments['result'].error
+
+    return response
 
 
 def extract_query_from_content(content):

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

@@ -1,7 +1,7 @@
 from monocle_apptrace.instrumentation.metamodel.llamaindex import (
     _helper,
 )
-from monocle_apptrace.instrumentation.common.utils import resolve_from_alias, get_llm_type
+from monocle_apptrace.instrumentation.common.utils import resolve_from_alias, get_llm_type, get_status, get_status_code
 
 INFERENCE = {
     "type": "inference.framework",
@@ -55,8 +55,16 @@ INFERENCE = {
             "attributes": [
                 {
                     "_comment": "this is response from LLM",
+                    "attribute": "status",
+                    "accessor": lambda arguments: get_status(arguments)
+                },
+{
+                    "attribute": "status_code",
+                    "accessor": lambda arguments: get_status_code(arguments)
+                },
+                {
                     "attribute": "response",
-                    "accessor": lambda arguments: _helper.extract_assistant_message(arguments['result'])
+                    "accessor": lambda arguments: _helper.extract_assistant_message(arguments)
                 }
             ]
         },

monocle_apptrace/instrumentation/metamodel/openai/_helper.py

@@ -6,11 +6,12 @@ and assistant messages from various input formats.
 import logging
 from monocle_apptrace.instrumentation.common.utils import (
     Option,
-    get_keys_as_tuple,
-    get_nested_value,
     try_option,
+    get_exception_message,
+    get_parent_span,
+    get_status_code,
 )
-from monocle_apptrace.instrumentation.common.span_handler import NonFrameworkSpanHandler
+from monocle_apptrace.instrumentation.common.span_handler import NonFrameworkSpanHandler, WORKFLOW_TYPE_MAP
 
 logger = logging.getLogger(__name__)
 
@@ -34,13 +35,23 @@ def extract_messages(kwargs):
         return []
 
 
-def extract_assistant_message(response):
+def extract_assistant_message(arguments):
     try:
-        if hasattr(response,"output_text") and len(response.output_text):
-            return response.output_text
-        if response is not None and hasattr(response,"choices") and len(response.choices) >0:
-            if hasattr(response.choices[0],"message"):
-                return response.choices[0].message.content
+        status = get_status_code(arguments)
+        response: str = ""
+        if status == 'success':
+            response = arguments["result"]
+            if hasattr(response,"output_text") and len(response.output_text):
+                return response.output_text
+            if response is not None and hasattr(response,"choices") and len(response.choices) >0:
+                if hasattr(response.choices[0],"message"):
+                    return response.choices[0].message.content
+        else:
+            if arguments["exception"] is not None:
+                response = get_exception_message(arguments)
+            elif hasattr(arguments["result"], "error"):
+                response = arguments["result"].error
+        return response
     except (IndexError, AttributeError) as e:
         logger.warning("Warning: Error occurred in extract_assistant_message: %s", str(e))
         return None
@@ -117,9 +128,19 @@ def get_inference_type(instance):
         return 'openai'
 
 class OpenAISpanHandler(NonFrameworkSpanHandler):
+    def is_teams_span_in_progress(self) -> bool:
+        return self.is_framework_span_in_progess() and self.get_workflow_name_in_progress() == WORKFLOW_TYPE_MAP["teams.ai"]
+
     # If openAI is being called by Teams AI SDK, then retain the metadata part of the span events
     def skip_processor(self, to_wrap, wrapped, instance, span, args, kwargs) -> list[str]:
-        if self.is_framework_span_in_progess() and self.get_workflow_name_in_progress() == "workflow.teams_ai":
+        if self.is_teams_span_in_progress():
             return ["attributes", "events.data.input", "events.data.output"]
         else:
             return super().skip_processor(to_wrap, wrapped, instance, span, args, kwargs)
+
+    def hydrate_events(self, to_wrap, wrapped, instance, args, kwargs, ret_result, span, parent_span=None, ex:Exception=None) -> bool:
+        # If openAI is being called by Teams AI SDK, then copy parent
+        if self.is_teams_span_in_progress() and ex is None:
+            return super().hydrate_events(to_wrap, wrapped, instance, args, kwargs, ret_result, span=parent_span, parent_span=None, ex=ex)
+
+        return super().hydrate_events(to_wrap, wrapped, instance, args, kwargs, ret_result, span, parent_span=parent_span, ex=ex)

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

@@ -8,6 +8,9 @@ from monocle_apptrace.instrumentation.metamodel.openai import (
 from monocle_apptrace.instrumentation.common.utils import (
     patch_instance_method,
     resolve_from_alias,
+    get_status,
+    get_exception_status_code,
+    get_status_code,
 )
 
 logger = logging.getLogger(__name__)
@@ -199,8 +202,16 @@ INFERENCE = {
                     "_comment": "this is result from LLM",
                     "attribute": "response",
                     "accessor": lambda arguments: _helper.extract_assistant_message(
-                        arguments["result"]
+                        arguments,
                     ),
+                },
+                {
+                    "attribute": "status",
+                    "accessor": lambda arguments: get_status(arguments)
+                },
+                {
+                    "attribute": "status_code",
+                    "accessor": lambda arguments: get_status_code(arguments)
                 }
             ],
         },

monocle_apptrace/instrumentation/metamodel/teamsai/_helper.py

@@ -1,3 +1,4 @@
+import logging
 from monocle_apptrace.instrumentation.common.utils import MonocleSpanException
 from monocle_apptrace.instrumentation.common.utils import (
     Option,
@@ -7,6 +8,9 @@ from monocle_apptrace.instrumentation.common.utils import (
     get_exception_message,
     get_exception_status_code
 )
+
+logger = logging.getLogger(__name__)
+
 def capture_input(arguments):
     """
     Captures the input from Teams AI state.
@@ -18,6 +22,7 @@ def capture_input(arguments):
     try:
         # Get the memory object from kwargs
         kwargs = arguments.get("kwargs", {})
+        messages = []
 
         # If memory exists, try to get the input from temp
         if "memory" in kwargs:
@@ -29,14 +34,20 @@ def capture_input(arguments):
                 if temp and hasattr(temp, "get"):
                     input_value = temp.get("input")
                     if input_value:
-                        return str(input_value)
-
+                        messages.append({'user': str(input_value)})
+        system_prompt = ""
+        try:
+            system_prompt = kwargs.get("template").prompt.sections[0].sections[0].template
+            messages.append({'system': system_prompt})
+        except Exception as e:
+            print(f"Debug - Error accessing system prompt: {str(e)}")
+            
         # Try alternative path through context if memory path fails
         context = kwargs.get("context")
         if hasattr(context, "activity") and hasattr(context.activity, "text"):
-            return str(context.activity.text)
+            messages.append({'user': str(context.activity.text)})
 
-        return "No input found in memory or context"
+        return [str(message) for message in messages]
     except Exception as e:
         print(f"Debug - Arguments structure: {str(arguments)}")
         print(f"Debug - kwargs: {str(kwargs)}")
@@ -59,6 +70,41 @@ def capture_prompt_info(arguments):
     except Exception as e:
         return f"Error capturing prompt: {str(e)}"
 
+def capture_prompt_template_info(arguments):
+    """Captures prompt information from ActionPlanner state"""
+    try:
+        kwargs = arguments.get("kwargs", {})
+        prompt = kwargs.get("prompt")
+
+        if hasattr(prompt,"prompt") and prompt.prompt is not None:
+            if "_text" in prompt.prompt.__dict__:
+                prompt_template = prompt.prompt.__dict__.get("_text", None)
+                return prompt_template
+            elif "_sections" in prompt.prompt.__dict__ and prompt.prompt._sections is not None:
+                sections = prompt.prompt._sections[0].__dict__.get("_sections", None)
+                if sections is not None and "_template" in sections[0].__dict__:
+                    return sections[0].__dict__.get("_template", None)
+
+
+        return "No prompt information found"
+    except Exception as e:
+        return f"Error capturing prompt: {str(e)}"
+
+def status_check(arguments):
+    if hasattr(arguments["result"], "error") and arguments["result"].error is not None:
+        error_msg:str = arguments["result"].error
+        error_code:str = arguments["result"].status if hasattr(arguments["result"], "status") else "unknown"
+        raise MonocleSpanException(f"Error: {error_code} - {error_msg}")
+
+def get_prompt_template(arguments):
+    pass
+    return {
+        "prompt_template_name": capture_prompt_info(arguments),
+        "prompt_template": capture_prompt_template_info(arguments),
+        "prompt_template_description": get_nested_value(arguments.get("kwargs", {}), ["prompt", "config", "description"]),
+        "prompt_template_type": get_nested_value(arguments.get("kwargs", {}), ["prompt", "config", "type"])
+    }
+
 def get_status_code(arguments):
     if arguments["exception"] is not None:
         return get_exception_status_code(arguments)

monocle_apptrace/instrumentation/metamodel/teamsai/entities/inference/actionplanner_output_processor.py

@@ -28,22 +28,42 @@ ACTIONPLANNER_OUTPUT_PROCESSOR = {
             {
                 "attribute": "tokenizer",
                 "accessor": lambda arguments: arguments["instance"]._options.tokenizer.__class__.__name__ if hasattr(arguments["instance"], "_options") else "GPTTokenizer"
-            },
-            {
-                "attribute": "prompt_name",
-                "accessor": _helper.capture_prompt_info
-            },
-            {
-                "attribute": "validator",
-                "accessor": lambda arguments: arguments["kwargs"].get("validator").__class__.__name__ if arguments.get("kwargs", {}).get("validator") else "DefaultResponseValidator"
-            },
-            {
-                "attribute": "memory_type",
-                "accessor": lambda arguments: arguments["kwargs"].get("memory").__class__.__name__ if arguments.get("kwargs", {}).get("memory") else "unknown"
             }
         ]
     ],
     "events": [
+        {
+            "name": "data.input",
+            "_comment": "input configuration to ActionPlanner",
+            "attributes": [
+               {
+                    "_comment": "execution metadata",
+                    "accessor": lambda arguments: _helper.get_prompt_template(arguments)
+                },
+                {
+                    "attribute": "validator",
+                    "accessor": lambda arguments: arguments["kwargs"].get("validator").__class__.__name__ if arguments.get("kwargs", {}).get("validator") else "DefaultResponseValidator"
+                },
+                {
+                    "attribute": "memory_type",
+                    "accessor": lambda arguments: arguments["kwargs"].get("memory").__class__.__name__ if arguments.get("kwargs", {}).get("memory") else "unknown"
+                }
+            ]
+        },
+        {
+            "name": "data.output",
+            "_comment": "output from ActionPlanner",
+            "attributes": [
+                {
+                    "attribute": "status",
+                    "accessor": lambda arguments: _helper.status_check(arguments)
+                },
+                {
+                    "attribute": "response",
+                    "accessor": lambda arguments: arguments["result"].message.content if hasattr(arguments["result"], "message") else str(arguments["result"])
+                }
+            ]
+        },
         {
             "name": "metadata",
             "attributes": [

monocle_apptrace/instrumentation/metamodel/teamsai/methods.py

@@ -9,31 +9,44 @@ from monocle_apptrace.instrumentation.metamodel.teamsai.entities.inference.teams
 )
 from monocle_apptrace.instrumentation.metamodel.teamsai.entities.inference.actionplanner_output_processor import (
     ACTIONPLANNER_OUTPUT_PROCESSOR,
-)
-
-
+) 
 def get_id(args, kwargs):
     """
     Extracts the ID from the context.
     """
     scopes: dict[str, dict[str:str]] = {}
     context = kwargs.get("context")
-    if context and context.activity and context.activity.conversation.id:
-        conversation_id = context.activity.conversation.id or ""
-        user_aad_object_id = context.activity.from_property.aad_object_id or ""
-        user_teams_id = context.activity.from_property.id or ""
+    if context and context.activity and context.activity.channel_id:
         channel_id = context.activity.channel_id or ""
-        recipient_id = context.activity.recipient.id or ""
-        recipient_aad_object_id = context.activity.recipient.aad_object_id or ""
-        scopes[f"teams.conversation.conversation.id"] = conversation_id
-        scopes[f"teams.user.from_property.aad_object_id"] = user_aad_object_id
-        scopes[f"teams.user.from_property.id"] = user_teams_id
         scopes[f"teams.channel.channel_id"] = channel_id
-        scopes[f"teams.channel.recipient.id"] = recipient_id
-        scopes[f"teams.channel.recipient.aad_object_id"] = recipient_aad_object_id
+        if channel_id == "msteams":
+            scopes[f"msteams.activity.type"] = context.activity.type or ""
 
-    return scopes
+            if hasattr(context.activity,"conversation"):
+                scopes[f"msteams.conversation.id"] = context.activity.conversation.id or ""
+                scopes[f"msteams.conversation.type"] = context.activity.conversation.conversation_type or ""
+                scopes[f"msteams.conversation.name"] = context.activity.conversation.name or ""
 
+            if hasattr(context.activity,"from_property"):
+                scopes[f"msteams.user.from_property.id"] = context.activity.from_property.id or ""
+                scopes[f"msteams.user.from_property.name"] = context.activity.from_property.name or ""
+                scopes[f"msteams.user.from_property.role"] = context.activity.from_property.role or ""
+
+            if hasattr(context.activity,"recipient"):
+                scopes[f"msteams.recipient.id"] = context.activity.recipient.id or ""
+
+            if hasattr(context.activity,"channel_data"):
+                if "tenant" in context.activity.channel_data:
+                    scopes[f"msteams.channel_data.tenant.id"] = context.activity.channel_data['tenant']['id'] or ""
+                if "team" in context.activity.channel_data:
+                    scopes[f"msteams.channel_data.team.id"] = context.activity.channel_data['team']['id'] or ""
+                    if "name" in context.activity.channel_data['team']:
+                        scopes[f"msteams.channel_data.team.name"] = context.activity.channel_data['team']['name'] or ""
+                if "channel" in context.activity.channel_data:
+                    scopes[f"msteams.channel_data.channel.id"] = context.activity.channel_data['channel']['id'] or ""
+                    if "name" in context.activity.channel_data['channel']:
+                        scopes[f"msteams.channel_data.channel.name"] = context.activity.channel_data['channel']['name'] or ""
+    return scopes
 
 TEAMAI_METHODS = [
     {
@@ -55,6 +68,6 @@ TEAMAI_METHODS = [
         "object": "ActionPlanner",
         "method": "complete_prompt",
         "scope_values": get_id,
-        "wrapper_method": ascopes_wrapper,
-    },
+        "wrapper_method": ascopes_wrapper,  
+    }
 ]