monocle-apptrace 0.3.0b6__py3-none-any.whl → 0.3.1__py3-none-any.whl

monocle_apptrace/instrumentation/metamodel/llamaindex/methods.py

@@ -13,7 +13,6 @@ LLAMAINDEX_METHODS = [
         "package": "llama_index.core.indices.base_retriever",
         "object": "BaseRetriever",
         "method": "retrieve",
-        "span_name": "llamaindex.retrieve",
         "wrapper_method": task_wrapper,
         "output_processor": RETRIEVAL
     },
@@ -21,7 +20,6 @@ LLAMAINDEX_METHODS = [
         "package": "llama_index.core.indices.base_retriever",
         "object": "BaseRetriever",
         "method": "aretrieve",
-        "span_name": "llamaindex.retrieve",
         "wrapper_method": atask_wrapper,
         "output_processor": RETRIEVAL
     },
@@ -29,23 +27,18 @@ LLAMAINDEX_METHODS = [
         "package": "llama_index.core.base.base_query_engine",
         "object": "BaseQueryEngine",
         "method": "query",
-        "span_name": "llamaindex.query",
-        "wrapper_method": task_wrapper,
-        "span_type": "workflow"
+        "wrapper_method": task_wrapper
     },
     {
         "package": "llama_index.core.base.base_query_engine",
         "object": "BaseQueryEngine",
         "method": "aquery",
-        "span_name": "llamaindex.query",
-        "wrapper_method": atask_wrapper,
-        "span_type": "workflow"
+        "wrapper_method": atask_wrapper
     },
     {
         "package": "llama_index.core.llms.custom",
         "object": "CustomLLM",
         "method": "chat",
-        "span_name": "llamaindex.llmchat",
         "wrapper_method": task_wrapper,
         "output_processor": INFERENCE
     },
@@ -53,7 +46,6 @@ LLAMAINDEX_METHODS = [
         "package": "llama_index.core.llms.custom",
         "object": "CustomLLM",
         "method": "achat",
-        "span_name": "llamaindex.llmchat",
         "wrapper_method": atask_wrapper,
         "output_processor": INFERENCE,
         
@@ -62,7 +54,6 @@ LLAMAINDEX_METHODS = [
         "package": "llama_index.llms.openai.base",
         "object": "OpenAI",
         "method": "chat",
-        "span_name": "llamaindex.openai",
         "wrapper_method": task_wrapper,
         "output_processor": INFERENCE
     },
@@ -70,7 +61,6 @@ LLAMAINDEX_METHODS = [
         "package": "llama_index.llms.openai.base",
         "object": "OpenAI",
         "method": "achat",
-        "span_name": "llamaindex.openai",
         "wrapper_method": atask_wrapper,
         "output_processor": INFERENCE
     },
@@ -78,7 +68,6 @@ LLAMAINDEX_METHODS = [
         "package": "llama_index.llms.mistralai.base",
         "object": "MistralAI",
         "method": "chat",
-        "span_name": "llamaindex.mistralai",
         "wrapper_method": task_wrapper,
         "output_processor": INFERENCE
     },
@@ -86,7 +75,6 @@ LLAMAINDEX_METHODS = [
         "package": "llama_index.llms.mistralai.base",
         "object": "MistralAI",
         "method": "achat",
-        "span_name": "llamaindex.mistralai",
         "wrapper_method": atask_wrapper,
         "output_processor": INFERENCE
     },
@@ -94,7 +82,6 @@ LLAMAINDEX_METHODS = [
         "package": "llama_index.core.agent",
         "object": "ReActAgent",
         "method": "chat",
-        "span_name": "react.agent",
         "wrapper_method": task_wrapper,
         "output_processor": AGENT
     }

monocle_apptrace/instrumentation/metamodel/openai/_helper.py

@@ -19,6 +19,10 @@ def extract_messages(kwargs):
     """Extract system and user messages"""
     try:
         messages = []
+        if 'instructions' in kwargs:
+            messages.append({'instructions': kwargs.get('instructions', {})})
+        if 'input' in kwargs:
+            messages.append({'input': kwargs.get('input', {})})
         if 'messages' in kwargs and len(kwargs['messages']) >0:
             for msg in kwargs['messages']:
                 if msg.get('content') and msg.get('role'):
@@ -32,6 +36,8 @@ def extract_messages(kwargs):
 
 def extract_assistant_message(response):
     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
@@ -85,10 +91,9 @@ def update_span_from_llm_response(response):
             response_metadata = response.response_metadata
             token_usage = response_metadata.get("token_usage")
         if token_usage is not None:
-            meta_dict.update(
-                {"completion_tokens": getattr(response.usage, "completion_tokens", None)})
-            meta_dict.update({"prompt_tokens": getattr(response.usage, "prompt_tokens", None)})
-            meta_dict.update({"total_tokens": getattr(response.usage, "total_tokens", None)})
+            meta_dict.update({"completion_tokens": getattr(token_usage,"completion_tokens",None) or getattr(token_usage,"output_tokens",None)})
+            meta_dict.update({"prompt_tokens": getattr(token_usage, "prompt_tokens", None) or getattr(token_usage, "input_tokens", None)})
+            meta_dict.update({"total_tokens": getattr(token_usage,"total_tokens")})
     return meta_dict
 
 def extract_vector_input(vector_input: dict):

monocle_apptrace/instrumentation/metamodel/openai/methods.py

@@ -28,7 +28,6 @@ OPENAI_METHODS = [
         "object": "Embeddings",
         "method": "create",
         "wrapper_method": task_wrapper,
-        "span_name": "openai_embeddings",
         "span_handler": "non_framework_handler",
         "output_processor": RETRIEVAL
     },
@@ -37,9 +36,24 @@ OPENAI_METHODS = [
         "object": "AsyncEmbeddings",
         "method": "create",
         "wrapper_method": atask_wrapper,
-        "span_name": "openai_embeddings",
         "span_handler": "non_framework_handler",
         "output_processor": RETRIEVAL
+    },
+    {
+        "package": "openai.resources.responses",
+        "object": "Responses",
+        "method": "create",
+        "wrapper_method": task_wrapper,
+        "span_handler": "non_framework_handler",
+        "output_processor": INFERENCE
+    },
+    {
+        "package": "openai.resources.responses",
+        "object": "AsyncResponses",
+        "method": "create",
+        "wrapper_method": atask_wrapper,
+        "span_handler": "non_framework_handler",
+        "output_processor": INFERENCE
     }
 
 ]

monocle_apptrace/instrumentation/metamodel/requests/_helper.py

@@ -2,6 +2,36 @@ import os
 from  monocle_apptrace.instrumentation.metamodel.requests import allowed_urls
 from opentelemetry.propagate import inject
 from monocle_apptrace.instrumentation.common.span_handler import SpanHandler
+from monocle_apptrace.instrumentation.common.utils import add_monocle_trace_state
+from urllib.parse import urlparse, ParseResult
+
+
+def get_route(kwargs):
+    url:str = kwargs['url']
+    parsed_url:ParseResult = urlparse(url)
+    return f"{parsed_url.netloc}{parsed_url.path}"
+
+def get_method(kwargs) -> str:
+    return kwargs['method'] if 'method' in kwargs else 'GET'
+
+def get_params(kwargs) -> dict:
+    url:str = kwargs['url']
+    parsed_url:ParseResult = urlparse(url)
+    return parsed_url.query
+
+def get_headers(kwargs) -> dict:
+    return kwargs['headers'] if 'headers' in kwargs else {}
+
+def get_body(kwargs) -> dict:
+    body = {}
+    return body
+
+def extract_response(result) -> str:
+    return result.text if hasattr(result, 'text') else str(result)
+
+def extract_status(result) -> str:
+    return f"{result.status_code} {result.reason}"
+
 
 def request_pre_task_processor(kwargs):
     # add traceparent to the request headers in kwargs
@@ -9,6 +39,7 @@ def request_pre_task_processor(kwargs):
         headers = {}
     else:
         headers = kwargs['headers'].copy()
+    add_monocle_trace_state(headers)
     inject(headers)
     kwargs['headers'] = headers
 

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

@@ -0,0 +1,51 @@
+from monocle_apptrace.instrumentation.metamodel.requests import _helper
+REQUEST_HTTP_PROCESSOR = {
+    "type": "http.send",
+    "attributes": [
+        [
+            {
+                "_comment": "request method, request URI",
+                "attribute": "method",
+                "accessor": lambda arguments: _helper.get_method(arguments['kwargs'])
+            },
+            {
+                "_comment": "request method, request URI",
+                "attribute": "URL",
+                "accessor": lambda arguments: _helper.get_route(arguments['kwargs'])
+            }
+
+        ]
+    ],
+    "events": [
+        {"name": "data.input",
+         "attributes": [
+             {
+                 "_comment": "route params",
+                 "attribute": "http.params",
+                 "accessor": lambda arguments: _helper.get_params(arguments['kwargs'])
+             },
+             {
+                 "_comment": "route body",
+                 "attribute": "body",
+                 "accessor": lambda arguments: _helper.get_body(arguments['kwargs'])
+             },
+
+         ]
+         },
+        {
+            "name": "data.output",
+            "attributes": [
+                {
+                    "_comment": "status from HTTP response",
+                    "attribute": "status",
+                    "accessor": lambda arguments: _helper.extract_status(arguments['result'])
+                },
+                {
+                    "_comment": "this is result from LLM",
+                    "attribute": "response",
+                    "accessor": lambda arguments: _helper.extract_response(arguments['result'])
+                }
+            ]
+        }
+    ]
+}

monocle_apptrace/instrumentation/metamodel/requests/methods.py

@@ -1,12 +1,13 @@
 from monocle_apptrace.instrumentation.common.wrapper import task_wrapper
+from monocle_apptrace.instrumentation.metamodel.requests.entities.http import REQUEST_HTTP_PROCESSOR
 
 REQUESTS_METHODS = [
     {
         "package": "requests.sessions",
         "object": "Session",
         "method": "request",
-        "span_name": "http_requests",
         "wrapper_method": task_wrapper,
         "span_handler":"request_handler",
+        "output_processor": REQUEST_HTTP_PROCESSOR
     }
 ]

monocle_apptrace/instrumentation/metamodel/teamsai/_helper.py

@@ -0,0 +1,58 @@
+from monocle_apptrace.instrumentation.common.utils import MonocleSpanException
+def capture_input(arguments):
+    """
+    Captures the input from Teams AI state.
+    Args:
+        arguments (dict): Arguments containing state and context information
+    Returns:
+        str: The input message or error message
+    """
+    try:
+        # Get the memory object from kwargs
+        kwargs = arguments.get("kwargs", {})
+
+        # If memory exists, try to get the input from temp
+        if "memory" in kwargs:
+            memory = kwargs["memory"]
+            # Check if it's a TurnState object
+            if hasattr(memory, "get"):
+                # Use proper TurnState.get() method
+                temp = memory.get("temp")
+                if temp and hasattr(temp, "get"):
+                    input_value = temp.get("input")
+                    if input_value:
+                        return str(input_value)
+
+        # 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)
+
+        return "No input found in memory or context"
+    except Exception as e:
+        print(f"Debug - Arguments structure: {str(arguments)}")
+        print(f"Debug - kwargs: {str(kwargs)}")
+        if "memory" in kwargs:
+            print(f"Debug - memory type: {type(kwargs['memory'])}")
+        return f"Error capturing input: {str(e)}"
+
+def capture_prompt_info(arguments):
+    """Captures prompt information from ActionPlanner state"""
+    try:
+        kwargs = arguments.get("kwargs", {})
+        prompt = kwargs.get("prompt")
+
+        if isinstance(prompt, str):
+            return prompt
+        elif hasattr(prompt, "name"):
+            return prompt.name
+
+        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}")

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

@@ -0,0 +1,80 @@
+from monocle_apptrace.instrumentation.metamodel.teamsai import (
+    _helper,
+)
+ACTIONPLANNER_OUTPUT_PROCESSOR = {
+    "type": "inference",
+    "attributes": [
+        [
+            {
+                "_comment": "planner type and configuration",
+                "attribute": "type",
+                "accessor": lambda arguments: "teams.planner"
+            },
+            {
+                "attribute": "planner_type",
+                "accessor": lambda arguments: "ActionPlanner"
+            },
+            {
+                "attribute": "max_repair_attempts",
+                "accessor": lambda arguments: arguments["instance"]._options.max_repair_attempts if hasattr(arguments["instance"], "_options") else 3
+            }
+        ],
+        [
+            {
+                "_comment": "model configuration",
+                "attribute": "model",
+                "accessor": lambda arguments: arguments["instance"]._options.model.__class__.__name__ if hasattr(arguments["instance"], "_options") else "unknown"
+            },
+            {
+                "attribute": "tokenizer",
+                "accessor": lambda arguments: arguments["instance"]._options.tokenizer.__class__.__name__ if hasattr(arguments["instance"], "_options") else "GPTTokenizer"
+            }
+        ]
+    ],
+    "events": [
+        {
+            "name": "data.input",
+            "_comment": "input configuration to ActionPlanner",
+            "attributes": [
+                {
+                    "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"
+                }
+            ]
+        },
+        {
+            "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": [
+                {
+                    "_comment": "execution metadata",
+                    "accessor": lambda arguments: {
+                        "latency_ms": arguments.get("latency_ms"),
+                        "feedback_enabled": arguments["instance"]._enable_feedback_loop if hasattr(arguments["instance"], "_enable_feedback_loop") else False
+                    }
+                }
+            ]
+        }
+    ]
+}

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

@@ -0,0 +1,70 @@
+from monocle_apptrace.instrumentation.metamodel.teamsai import (
+    _helper,
+)
+TEAMAI_OUTPUT_PROCESSOR = {
+    "type": "inference",
+    "attributes": [
+        [
+            {
+                "_comment": "provider type, name, deployment",
+                "attribute": "type",
+                "accessor": lambda arguments: "teams.openai"
+            },
+            {
+                "attribute": "provider_name",
+                "accessor": lambda arguments: "Microsoft Teams AI"
+            },
+            {
+                "attribute": "deployment",
+                "accessor": lambda arguments: arguments["instance"]._options.default_model if hasattr(arguments["instance"], "_options") else "unknown"
+            }
+        ],
+        [
+            {
+                "_comment": "LLM Model",
+                "attribute": "name",
+                "accessor": lambda arguments: arguments["instance"]._options.default_model if hasattr(arguments["instance"], "_options") else "unknown"
+            },
+            {
+                "attribute": "is_streaming",
+                "accessor": lambda arguments: arguments["instance"]._options.stream if hasattr(arguments["instance"], "_options") else False
+            }
+        ]
+    ],
+    "events": [
+        {
+            "name": "data.input",
+            "_comment": "input to Teams AI",
+            "attributes": [
+                {
+                    "attribute": "input",
+                    "accessor": _helper.capture_input
+                }
+            ]
+        },
+        {
+            "name": "data.output",
+            "_comment": "output from Teams AI",
+            "attributes": [
+                {
+                    "attribute": "response",
+                    "accessor": lambda arguments: arguments["result"].message.content if hasattr(arguments["result"], "message") else str(arguments["result"])
+                }
+            ]
+        },
+        {
+            "name": "metadata",
+            "attributes": [
+                {
+                    "_comment": "metadata from Teams AI response",
+                    "accessor": lambda arguments: {
+                        "prompt_tokens": arguments["result"].get("usage", {}).get("prompt_tokens", 0),
+                        "completion_tokens": arguments["result"].get("usage", {}).get("completion_tokens", 0),
+                        "total_tokens": arguments["result"].get("usage", {}).get("total_tokens", 0),
+                        "latency_ms": arguments.get("latency_ms")
+                    }
+                }
+            ]
+        }
+    ]
+}

monocle_apptrace/instrumentation/metamodel/teamsai/methods.py

@@ -0,0 +1,26 @@
+from monocle_apptrace.instrumentation.common.wrapper import atask_wrapper, task_wrapper
+from monocle_apptrace.instrumentation.metamodel.teamsai.entities.inference.teamsai_output_processor import (
+    TEAMAI_OUTPUT_PROCESSOR,
+)
+from monocle_apptrace.instrumentation.metamodel.teamsai.entities.inference.actionplanner_output_processor import (
+    ACTIONPLANNER_OUTPUT_PROCESSOR,
+)
+
+TEAMAI_METHODS =[
+    {
+        "package": "teams.ai.models.openai_model",
+        "object": "OpenAIModel",
+        "method": "complete_prompt",
+        "span_name": "teamsai.workflow",
+        "wrapper_method": atask_wrapper,
+        "output_processor": TEAMAI_OUTPUT_PROCESSOR
+    },
+    {
+        "package": "teams.ai.planners.action_planner",
+        "object": "ActionPlanner",
+        "method": "complete_prompt",
+        "span_name": "teamsai.workflow",
+        "wrapper_method": atask_wrapper,
+        "output_processor": ACTIONPLANNER_OUTPUT_PROCESSOR
+    }
+]

{monocle_apptrace-0.3.0b6.dist-info → monocle_apptrace-0.3.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: monocle_apptrace
-Version: 0.3.0b6
+Version: 0.3.1
 Summary: package with monocle genAI tracing
 Project-URL: Homepage, https://github.com/monocle2ai/monocle
 Project-URL: Issues, https://github.com/monocle2ai/monocle/issues
@@ -20,6 +20,7 @@ Requires-Dist: boto3==1.35.19; extra == 'aws'
 Provides-Extra: azure
 Requires-Dist: azure-storage-blob==12.22.0; extra == 'azure'
 Provides-Extra: dev
+Requires-Dist: anthropic==0.49.0; extra == 'dev'
 Requires-Dist: azure-storage-blob==12.22.0; extra == 'dev'
 Requires-Dist: boto3==1.34.131; extra == 'dev'
 Requires-Dist: chromadb==0.4.22; extra == 'dev'