monocle-apptrace 0.1.1__py3-none-any.whl → 0.3.0__py3-none-any.whl

monocle_apptrace/{metamodel/maps/lang_chain_methods.json → instrumentation/metamodel/langchain/methods.py}

@@ -1,106 +1,111 @@
-{ 
-"wrapper_methods" : [
+from monocle_apptrace.instrumentation.common.wrapper import atask_wrapper, task_wrapper
+from monocle_apptrace.instrumentation.metamodel.langchain.entities.inference import (
+    INFERENCE,
+)
+from monocle_apptrace.instrumentation.metamodel.langchain.entities.retrieval import (
+    RETRIEVAL,
+)
+
+LANGCHAIN_METHODS = [
     {
         "package": "langchain.prompts.base",
         "object": "BasePromptTemplate",
         "method": "invoke",
-        "wrapper_package": "wrap_common",
-        "wrapper_method": "task_wrapper"
+        "wrapper_method": task_wrapper,
+        "span_type": "workflow"
     },
     {
         "package": "langchain.prompts.base",
         "object": "BasePromptTemplate",
         "method": "ainvoke",
-        "wrapper_package": "wrap_common",
-        "wrapper_method": "atask_wrapper"
+        "wrapper_method": atask_wrapper,
+        "span_type": "workflow"
     },
     {
         "package": "langchain.chat_models.base",
         "object": "BaseChatModel",
         "method": "invoke",
-        "wrapper_package": "wrap_common",
-        "wrapper_method": "llm_wrapper"
+        "wrapper_method": task_wrapper,
+        "output_processor": INFERENCE
     },
     {
         "package": "langchain.chat_models.base",
         "object": "BaseChatModel",
         "method": "ainvoke",
-        "wrapper_package": "wrap_common",
-        "wrapper_method": "allm_wrapper"
+        "wrapper_method": atask_wrapper,
+        "output_processor": INFERENCE
     },
     {
         "package": "langchain_core.language_models.llms",
         "object": "LLM",
         "method": "_generate",
-        "wrapper_package": "wrap_common",
-        "wrapper_method": "llm_wrapper"
+        "wrapper_method": task_wrapper,
+        "output_processor": INFERENCE
     },
     {
         "package": "langchain_core.language_models.llms",
         "object": "LLM",
         "method": "_agenerate",
-        "wrapper_package": "wrap_common",
-        "wrapper_method": "llm_wrapper"
+        "wrapper_method": atask_wrapper,
+        "output_processor": INFERENCE
+    },
+    {
+        "package": "langchain_core.language_models.llms",
+        "object": "BaseLLM",
+        "method": "invoke",
+        "wrapper_method": task_wrapper,
+        "output_processor": INFERENCE
+    },
+    {
+        "package": "langchain_core.language_models.llms",
+        "object": "BaseLLM",
+        "method": "ainvoke",
+        "wrapper_method": atask_wrapper,
+        "output_processor": INFERENCE
     },
     {
         "package": "langchain_core.retrievers",
         "object": "BaseRetriever",
         "method": "invoke",
-        "wrapper_package": "wrap_common",
-        "wrapper_method": "task_wrapper"
+        "wrapper_method": task_wrapper,
+        "output_processor": RETRIEVAL
+
     },
     {
         "package": "langchain_core.retrievers",
         "object": "BaseRetriever",
         "method": "ainvoke",
-        "wrapper_package": "wrap_common",
-        "wrapper_method": "atask_wrapper"
+        "wrapper_method": atask_wrapper,
+        "output_processor": RETRIEVAL
     },
     {
         "package": "langchain.schema",
         "object": "BaseOutputParser",
         "method": "invoke",
-        "wrapper_package": "wrap_common",
-        "wrapper_method": "task_wrapper"
+        "wrapper_method": task_wrapper,
+        "span_type": "workflow"
     },
     {
         "package": "langchain.schema",
         "object": "BaseOutputParser",
         "method": "ainvoke",
-        "wrapper_package": "wrap_common",
-        "wrapper_method": "atask_wrapper"
+        "wrapper_method": atask_wrapper,
+        "span_type": "workflow"
     },
     {
         "package": "langchain.schema.runnable",
         "object": "RunnableSequence",
         "method": "invoke",
         "span_name": "langchain.workflow",
-        "wrapper_package": "wrap_common",
-        "wrapper_method": "task_wrapper"
+        "wrapper_method": task_wrapper,
+        "span_type": "workflow"
     },
     {
         "package": "langchain.schema.runnable",
         "object": "RunnableSequence",
         "method": "ainvoke",
         "span_name": "langchain.workflow",
-        "wrapper_package": "wrap_common",
-        "wrapper_method": "atask_wrapper"
-    },
-    {
-        "package": "langchain.schema.runnable",
-        "object": "RunnableParallel",
-        "method": "invoke",
-        "span_name": "langchain.workflow",
-        "wrapper_package": "wrap_common",
-        "wrapper_method": "task_wrapper"
-    },
-    {
-        "package": "langchain.schema.runnable",
-        "object": "RunnableParallel",
-        "method": "ainvoke",
-        "span_name": "langchain.workflow",
-        "wrapper_package": "wrap_common",
-        "wrapper_method": "atask_wrapper"
+        "wrapper_method": atask_wrapper,
+        "span_type": "workflow"
     }
 ]
-}

monocle_apptrace/instrumentation/metamodel/langgraph/_helper.py

@@ -0,0 +1,48 @@
+from monocle_apptrace.instrumentation.common.utils import resolve_from_alias
+import logging
+logger = logging.getLogger(__name__)
+
+def handle_openai_response(response):
+    try:
+        if 'messages' in response:
+            output = response["messages"][-1]
+            return str(output.content)
+    except Exception as e:
+        logger.warning("Warning: Error occurred in handle_openai_response: %s", str(e))
+        return ""
+
+def agent_instructions(arguments):
+    if callable(arguments['kwargs']['agent'].instructions):
+        return arguments['kwargs']['agent'].instructions(arguments['kwargs']['context_variables'])
+    else:
+        return arguments['kwargs']['agent'].instructions
+
+def extract_input(arguments):
+    history = arguments['result']['messages']
+    for message in history:
+        if hasattr(message, 'content') and hasattr(message, 'type') and message.type == "human":  # Check if the message is a HumanMessage
+            return message.content
+
+def get_inference_endpoint(arguments):
+    inference_endpoint = resolve_from_alias(arguments['instance'].client.__dict__, ['azure_endpoint', 'api_base', '_base_url'])
+    return str(inference_endpoint)
+
+def tools(instance):
+    if hasattr(instance,'nodes') and ('tools' in instance.nodes):
+        tools= instance.nodes['tools']
+        if hasattr(tools,'bound') and hasattr(tools.bound,'tools_by_name'):
+            return list(tools.bound.tools_by_name.keys())
+
+
+def update_span_from_llm_response(response):
+    meta_dict = {}
+    token_usage = None
+    if response is not None and "messages" in response:
+        token = response["messages"][-1]
+        if token.response_metadata is not None:
+            token_usage = token.response_metadata["token_usage"]
+        if token_usage is not None:
+            meta_dict.update({"completion_tokens": token_usage.get('completion_tokens')})
+            meta_dict.update({"prompt_tokens": token_usage.get('prompt_tokens')})
+            meta_dict.update({"total_tokens": token_usage.get('total_tokens')})
+    return meta_dict

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

@@ -0,0 +1,56 @@
+from monocle_apptrace.instrumentation.metamodel.langgraph import (
+    _helper
+)
+INFERENCE = {
+      "type": "agent",
+      "attributes": [
+        [
+              {
+                "_comment": "agent type",
+                "attribute": "type",
+                "accessor": lambda arguments:'agent.oai'
+              },
+              {
+                "_comment": "name of the agent",
+                "attribute": "name",
+                "accessor": lambda arguments:arguments['instance'].name
+              },
+              {
+                "_comment": "agent tools",
+                "attribute": "tools",
+                "accessor": lambda arguments: _helper.tools(arguments['instance'])
+              }
+        ]
+      ],
+      "events": [
+        {
+          "name":"data.input",
+          "attributes": [
+            {
+                "_comment": "this is LLM input",
+                "attribute": "query",
+                "accessor": lambda arguments: _helper.extract_input(arguments)
+            }
+          ]
+        },
+        {
+          "name":"data.output",
+          "attributes": [
+            {
+                "_comment": "this is response from LLM",
+                "attribute": "response",
+                "accessor": lambda arguments: _helper.handle_openai_response(arguments['result'])
+            }
+          ]
+       },
+       {
+            "name": "metadata",
+            "attributes": [
+                {
+                    "_comment": "this is metadata usage from LLM",
+                    "accessor": lambda arguments: _helper.update_span_from_llm_response(arguments['result'])
+                }
+            ]
+        }
+      ]
+    }

monocle_apptrace/instrumentation/metamodel/langgraph/methods.py

@@ -0,0 +1,14 @@
+from monocle_apptrace.instrumentation.common.wrapper import task_wrapper
+from monocle_apptrace.instrumentation.metamodel.langgraph.entities.inference import (
+    INFERENCE,
+)
+LANGGRAPH_METHODS = [
+    {
+        "package": "langgraph.graph.state",
+         "object": "CompiledStateGraph",
+         "method": "invoke",
+         "span_name": "langgraph.graph.invoke",
+         "wrapper_method": task_wrapper,
+         "output_processor": INFERENCE
+    }
+]

monocle_apptrace/instrumentation/metamodel/llamaindex/_helper.py

@@ -0,0 +1,172 @@
+"""
+This module provides utility functions for extracting system, user,
+and assistant messages from various input formats.
+"""
+
+import logging
+from urllib.parse import urlparse
+from opentelemetry.sdk.trace import Span
+from monocle_apptrace.instrumentation.common.utils import (
+    Option,
+    get_keys_as_tuple,
+    get_nested_value,
+    try_option,
+)
+
+logger = logging.getLogger(__name__)
+
+
+def extract_tools(instance):
+    tools = []
+    if not hasattr(instance, 'state') or not hasattr(instance.state, 'task_dict'):
+        return []
+    try:
+        data = next(iter(instance.state.task_dict.values())).task
+    except (AttributeError, StopIteration):
+        return []
+
+    if hasattr(data,'extra_state') and 'sources' in data.extra_state:
+        for tool_output in data.extra_state['sources']:
+            tool_name = tool_output.tool_name
+            if tool_name:
+                tools.append(tool_name)
+    return tools
+
+
+def extract_messages(args):
+    """Extract system and user messages"""
+    try:
+        messages = []
+
+        def process_message(msg):
+            """Processes a single message and extracts relevant information."""
+            if hasattr(msg, 'content') and hasattr(msg, 'role'):
+                role = getattr(msg.role, 'value', msg.role)
+                content = msg.content if role == "system" else extract_query_from_content(msg.content)
+                messages.append({role: content})
+
+        if isinstance(args, (list, tuple)) and args:
+            for msg in args[0]:
+                process_message(msg)
+        if isinstance(args, dict):
+            for msg in args.get("messages", []):
+                process_message(msg)
+        if args and isinstance(args, tuple):
+            messages.append(args[0])
+
+        return [str(message) for message in messages]
+
+    except Exception as e:
+        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_query_from_content(content):
+    try:
+        query_prefix = "Query:"
+        answer_prefix = "Answer:"
+        query_start = content.find(query_prefix)
+        if query_start == -1:
+            return content
+
+        query_start += len(query_prefix)
+        answer_start = content.find(answer_prefix, query_start)
+        if answer_start == -1:
+            query = content[query_start:].strip()
+        else:
+            query = content[query_start:answer_start].strip()
+        return query
+    except Exception as e:
+        logger.warning("Warning: Error occurred in extract_query_from_content: %s", str(e))
+        return ""
+
+
+def extract_provider_name(instance):
+    provider_url = try_option(getattr, instance, 'api_base').and_then(lambda url: urlparse(url).hostname)
+    return provider_url
+
+
+def extract_inference_endpoint(instance):
+    inference_endpoint = try_option(getattr, instance._client.sdk_configuration, 'server_url').map(str)
+    return inference_endpoint.unwrap_or(extract_provider_name(instance))
+
+
+def extract_vectorstore_deployment(my_map):
+    if isinstance(my_map, dict):
+        if '_client_settings' in my_map:
+            client = my_map['_client_settings'].__dict__
+            host, port = get_keys_as_tuple(client, 'host', 'port')
+            if host:
+                return f"{host}:{port}" if port else host
+        keys_to_check = ['client', '_client']
+        host = __get_host_from_map(my_map, keys_to_check)
+        if host:
+            return host
+    else:
+        if hasattr(my_map, 'client') and '_endpoint' in my_map.client.__dict__:
+            return my_map.client.__dict__['_endpoint']
+        host, port = get_keys_as_tuple(my_map.__dict__, 'host', 'port')
+        if host:
+            return f"{host}:{port}" if port else host
+    return None
+
+
+def __get_host_from_map(my_map, keys_to_check):
+    for key in keys_to_check:
+        seed_connections = get_nested_value(my_map, [key, 'transport', 'seed_connections'])
+        if seed_connections and 'host' in seed_connections[0].__dict__:
+            return seed_connections[0].__dict__['host']
+    return None
+
+
+def resolve_from_alias(my_map, alias):
+    """Find a alias that is not none from list of aliases"""
+
+    for i in alias:
+        if i in my_map.keys():
+            return my_map[i]
+    return None
+
+
+def update_input_span_events(args):
+    if isinstance(args, tuple):
+        return args[0].query_str if len(args) > 0 else ""
+
+
+def update_output_span_events(results):
+    if isinstance(results, list) and len(results) >0:
+        output_arg_text = results[0].text
+        if len(output_arg_text) > 100:
+            output_arg_text = output_arg_text[:100] + "..."
+        return output_arg_text
+
+
+def update_span_from_llm_response(response, instance):
+    meta_dict = {}
+    if response is not None and hasattr(response, "raw"):
+        if response.raw is not None:
+            token_usage = response.raw.get("usage") if isinstance(response.raw, dict) else getattr(response.raw, "usage", None)
+            if token_usage is not None:
+                temperature = instance.__dict__.get("temperature", None)
+                meta_dict.update({"temperature": temperature})
+                if getattr(token_usage, "completion_tokens", None):
+                    meta_dict.update({"completion_tokens": getattr(token_usage, "completion_tokens")})
+                if getattr(token_usage, "prompt_tokens", None):
+                    meta_dict.update({"prompt_tokens": getattr(token_usage, "prompt_tokens")})
+                if getattr(token_usage, "total_tokens", None):
+                    meta_dict.update({"total_tokens": getattr(token_usage, "total_tokens")})
+    return meta_dict

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

@@ -0,0 +1,47 @@
+from monocle_apptrace.instrumentation.metamodel.llamaindex import (
+    _helper,
+)
+
+AGENT = {
+    "type": "agent",
+    "attributes": [
+        [
+            {
+                "_comment": "Agent name, type and Tools.",
+                "attribute": "name",
+                "accessor": lambda arguments: arguments['instance'].__class__.__name__
+            },
+            {
+                "attribute": "type",
+                "accessor": lambda arguments: 'Agent.oai'
+            },
+            {
+                "attribute": "tools",
+                "accessor": lambda arguments: _helper.extract_tools(arguments['instance'])
+            }
+        ]
+
+    ],
+    "events": [
+        {"name": "data.input",
+         "attributes": [
+
+             {
+                 "_comment": "this is instruction and user query to LLM",
+                 "attribute": "input",
+                 "accessor": lambda arguments: _helper.extract_messages(arguments['args'])
+             }
+         ]
+         },
+        {
+            "name": "data.output",
+            "attributes": [
+                {
+                    "_comment": "this is response from LLM",
+                    "attribute": "response",
+                    "accessor": lambda arguments: _helper.extract_assistant_message(arguments['result'])
+                }
+            ]
+        }
+    ]
+}

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

@@ -0,0 +1,73 @@
+from monocle_apptrace.instrumentation.metamodel.llamaindex import (
+    _helper,
+)
+from monocle_apptrace.instrumentation.common.utils import resolve_from_alias, get_llm_type
+
+INFERENCE = {
+    "type": "inference",
+    "attributes": [
+        [
+            {
+                "_comment": "provider type ,name , deployment , inference_endpoint",
+                "attribute": "type",
+                "accessor": lambda arguments: 'inference.' + (get_llm_type(arguments['instance']) or 'generic')
+
+            },
+            {
+                "attribute": "provider_name",
+                "accessor": lambda arguments: arguments['kwargs'].get('provider_name') or _helper.extract_provider_name(arguments['instance'])
+
+            },
+            {
+                "attribute": "deployment",
+                "accessor": lambda arguments: resolve_from_alias(arguments['instance'].__dict__, ['engine', 'azure_deployment', 'deployment_name', 'deployment_id', 'deployment'])
+            },
+            {
+                "attribute": "inference_endpoint",
+                "accessor": lambda arguments: resolve_from_alias(arguments['instance'].__dict__, ['azure_endpoint', 'api_base']) or _helper.extract_inference_endpoint(arguments['instance'])
+            }
+        ],
+        [
+            {
+                "_comment": "LLM Model",
+                "attribute": "name",
+                "accessor": lambda arguments: resolve_from_alias(arguments['instance'].__dict__, ['model', 'model_name'])
+            },
+            {
+                "attribute": "type",
+                "accessor": lambda arguments: 'model.llm.' + resolve_from_alias(arguments['instance'].__dict__, ['model', 'model_name'])
+            }
+        ]
+    ],
+    "events": [
+        {"name": "data.input",
+         "attributes": [
+
+             {
+                 "_comment": "this is instruction and user query to LLM",
+                 "attribute": "input",
+                 "accessor": lambda arguments: _helper.extract_messages(arguments['args'])
+             }
+         ]
+         },
+        {
+            "name": "data.output",
+            "attributes": [
+                {
+                    "_comment": "this is response from LLM",
+                    "attribute": "response",
+                    "accessor": lambda arguments: _helper.extract_assistant_message(arguments['result'])
+                }
+            ]
+        },
+        {
+            "name": "metadata",
+            "attributes": [
+                {
+                    "_comment": "this is metadata usage from LLM",
+                    "accessor": lambda arguments: _helper.update_span_from_llm_response(arguments['result'],arguments['instance'])
+                }
+            ]
+        }
+    ]
+}

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

@@ -0,0 +1,57 @@
+from monocle_apptrace.instrumentation.metamodel.llamaindex import (
+    _helper,
+)
+
+RETRIEVAL = {
+    "type": "retrieval",
+    "attributes": [
+        [
+            {
+                "_comment": "vector store name and type",
+                "attribute": "name",
+                "accessor": lambda arguments: type(arguments['instance']._vector_store).__name__
+            },
+            {
+                "attribute": "type",
+                "accessor": lambda arguments: 'vectorstore.' + type(arguments['instance']._vector_store).__name__
+            },
+            {
+                "attribute": "deployment",
+                "accessor": lambda arguments: _helper.extract_vectorstore_deployment(arguments['instance']._vector_store)
+            }
+        ],
+        [
+            {
+                "_comment": "embedding model name and type",
+                "attribute": "name",
+                "accessor": lambda arguments: arguments['instance']._embed_model.model_name
+            },
+            {
+                "attribute": "type",
+                "accessor": lambda arguments: 'model.embedding.' + arguments['instance']._embed_model.model_name
+            }
+        ]
+    ],
+    "events": [
+        {"name": "data.input",
+         "attributes": [
+
+             {
+                 "_comment": "this is instruction and user query to LLM",
+                 "attribute": "input",
+                 "accessor": lambda arguments: _helper.update_input_span_events(arguments['args'])
+             }
+         ]
+         },
+        {
+            "name": "data.output",
+            "attributes": [
+                {
+                    "_comment": "this is result from LLM",
+                    "attribute": "response",
+                    "accessor": lambda arguments: _helper.update_output_span_events(arguments['result'])
+                }
+            ]
+        }
+    ]
+}