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

monocle_apptrace/metamodel/maps/attributes/retrieval/llamaindex_entities.json

@@ -0,0 +1,31 @@
+{
+  "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: get_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"
+      }
+    ]
+  ]
+}

monocle_apptrace/metamodel/maps/botocore_methods.json

@@ -0,0 +1,13 @@
+{
+  "wrapper_methods": [
+    {
+      "package": "botocore.client",
+      "object": "ClientCreator",
+      "method": "create_client",
+      "wrapper_package": "wrap_common",
+      "wrapper_method": "task_wrapper",
+      "skip_span": true,
+      "output_processor": ["metamodel/maps/attributes/inference/botocore_entities.json"]
+    }
+  ]
+}

monocle_apptrace/metamodel/maps/haystack_methods.json

@@ -1,25 +1,45 @@
 {
 "wrapper_methods" :  [
+    {
+        "package": "haystack_integrations.components.retrievers.opensearch",
+        "object": "OpenSearchEmbeddingRetriever",
+        "method": "run",
+        "span_name": "haystack.retriever",
+        "wrapper_package": "wrap_common",
+        "wrapper_method": "task_wrapper",
+        "output_processor": ["metamodel/maps/attributes/retrieval/haystack_entities.json"]
+    },
+    {
+        "package": "haystack.components.retrievers.in_memory",
+        "object": "InMemoryEmbeddingRetriever",
+        "method": "run",
+        "span_name": "haystack.retriever",
+        "wrapper_package": "wrap_common",
+        "wrapper_method": "task_wrapper",
+        "output_processor": ["metamodel/maps/attributes/retrieval/haystack_entities.json"]
+    },
     {
         "package": "haystack.components.generators.openai",
         "object": "OpenAIGenerator",
         "method": "run",
-        "wrapper_package": "haystack.wrap_openai",
-        "wrapper_method": "wrap_openai"
+        "wrapper_package": "wrap_common",
+        "wrapper_method": "llm_wrapper",
+        "output_processor": ["metamodel/maps/attributes/inference/haystack_entities.json"]
     },
     {
         "package": "haystack.components.generators.chat.openai",
         "object": "OpenAIChatGenerator",
         "method": "run",
-        "wrapper_package": "haystack.wrap_openai",
-        "wrapper_method": "wrap_openai"
+        "wrapper_package": "wrap_common",
+        "wrapper_method": "llm_wrapper",
+        "output_processor": ["metamodel/maps/attributes/inference/haystack_entities.json"]
     },
     {
         "package": "haystack.core.pipeline.pipeline",
         "object": "Pipeline",
         "method": "run",
-        "wrapper_package": "haystack.wrap_pipeline",
-        "wrapper_method": "wrap"
+        "wrapper_package": "wrap_common",
+        "wrapper_method": "task_wrapper"
     }
 ] 
 }

monocle_apptrace/metamodel/maps/{lang_chain_methods.json → langchain_methods.json}

@@ -1,4 +1,4 @@
-{ 
+{
 "wrapper_methods" : [
     {
         "package": "langchain.prompts.base",
@@ -19,42 +19,65 @@
         "object": "BaseChatModel",
         "method": "invoke",
         "wrapper_package": "wrap_common",
-        "wrapper_method": "llm_wrapper"
+        "wrapper_method": "llm_wrapper",
+        "output_processor": ["metamodel/maps/attributes/inference/langchain_entities.json"]
     },
     {
         "package": "langchain.chat_models.base",
         "object": "BaseChatModel",
         "method": "ainvoke",
         "wrapper_package": "wrap_common",
-        "wrapper_method": "allm_wrapper"
+        "wrapper_method": "allm_wrapper",
+        "output_processor": ["metamodel/maps/attributes/inference/langchain_entities.json"]
     },
     {
         "package": "langchain_core.language_models.llms",
         "object": "LLM",
         "method": "_generate",
         "wrapper_package": "wrap_common",
-        "wrapper_method": "llm_wrapper"
+        "wrapper_method": "llm_wrapper",
+        "output_processor": ["metamodel/maps/attributes/inference/langchain_entities.json"]
     },
     {
         "package": "langchain_core.language_models.llms",
         "object": "LLM",
         "method": "_agenerate",
         "wrapper_package": "wrap_common",
-        "wrapper_method": "llm_wrapper"
+        "wrapper_method": "allm_wrapper",
+        "output_processor": ["metamodel/maps/attributes/inference/langchain_entities.json"]
+    },
+    {
+        "package": "langchain_core.language_models.llms",
+        "object": "BaseLLM",
+        "method": "invoke",
+        "wrapper_package": "wrap_common",
+        "wrapper_method": "llm_wrapper",
+        "output_processor": ["metamodel/maps/attributes/inference/langchain_entities.json"]
+    },
+    {
+        "package": "langchain_core.language_models.llms",
+        "object": "BaseLLM",
+        "method": "ainvoke",
+        "wrapper_package": "wrap_common",
+        "wrapper_method": "allm_wrapper",
+        "output_processor": ["metamodel/maps/attributes/inference/langchain_entities.json"]
     },
     {
         "package": "langchain_core.retrievers",
         "object": "BaseRetriever",
         "method": "invoke",
         "wrapper_package": "wrap_common",
-        "wrapper_method": "task_wrapper"
+        "wrapper_method": "task_wrapper",
+        "output_processor": ["metamodel/maps/attributes/retrieval/langchain_entities.json"]
+
     },
     {
         "package": "langchain_core.retrievers",
         "object": "BaseRetriever",
         "method": "ainvoke",
         "wrapper_package": "wrap_common",
-        "wrapper_method": "atask_wrapper"
+        "wrapper_method": "atask_wrapper",
+        "output_processor": ["metamodel/maps/attributes/retrieval/langchain_entities.json"]
     },
     {
         "package": "langchain.schema",
@@ -103,4 +126,4 @@
         "wrapper_method": "atask_wrapper"
     }
 ]
-}
+}

monocle_apptrace/metamodel/maps/{llama_index_methods.json → llamaindex_methods.json}

@@ -6,7 +6,8 @@
         "method": "retrieve",
         "span_name": "llamaindex.retrieve",
         "wrapper_package": "wrap_common",
-        "wrapper_method": "task_wrapper"
+        "wrapper_method": "task_wrapper",
+        "output_processor": ["metamodel/maps/attributes/retrieval/llamaindex_entities.json"]
     },
     {
         "package": "llama_index.core.indices.base_retriever",
@@ -14,7 +15,8 @@
         "method": "aretrieve",
         "span_name": "llamaindex.retrieve",
         "wrapper_package": "wrap_common",
-        "wrapper_method": "atask_wrapper"
+        "wrapper_method": "atask_wrapper",
+        "output_processor": ["metamodel/maps/attributes/retrieval/llamaindex_entities.json"]
     },
     {
         "package": "llama_index.core.base.base_query_engine",
@@ -38,7 +40,8 @@
         "method": "chat",
         "span_name": "llamaindex.llmchat",
         "wrapper_package": "wrap_common",
-        "wrapper_method": "task_wrapper"
+        "wrapper_method": "task_wrapper",
+        "output_processor": ["metamodel/maps/attributes/inference/llamaindex_entities.json"]
     },
     {
         "package": "llama_index.core.llms.custom",
@@ -46,7 +49,8 @@
         "method": "achat",
         "span_name": "llamaindex.llmchat",
         "wrapper_package": "wrap_common",
-        "wrapper_method": "atask_wrapper"
+        "wrapper_method": "atask_wrapper",
+        "output_processor": ["metamodel/maps/attributes/inference/llamaindex_entities.json"]
     },
     {
         "package": "llama_index.llms.openai.base",
@@ -55,8 +59,7 @@
         "span_name": "llamaindex.openai",
         "wrapper_package": "wrap_common",
         "wrapper_method": "llm_wrapper",
-        "span_name_getter_package" : "llamaindex",
-        "span_name_getter_mothod" : "get_llm_span_name_for_openai"
+        "output_processor": ["metamodel/maps/attributes/inference/llamaindex_entities.json"]
     },
     {
         "package": "llama_index.llms.openai.base",
@@ -64,7 +67,26 @@
         "method": "achat",
         "span_name": "llamaindex.openai",
         "wrapper_package": "wrap_common",
-        "wrapper_method": "allm_wrapper"
+        "wrapper_method": "allm_wrapper",
+        "output_processor": ["metamodel/maps/attributes/inference/llamaindex_entities.json"]
+    },
+    {
+        "package": "llama_index.llms.mistralai.base",
+        "object": "MistralAI",
+        "method": "chat",
+        "span_name": "llamaindex.mistralai",
+        "wrapper_package": "wrap_common",
+        "wrapper_method": "llm_wrapper",
+        "output_processor": ["metamodel/maps/attributes/inference/llamaindex_entities.json"]
+    },
+    {
+        "package": "llama_index.llms.mistralai.base",
+        "object": "MistralAI",
+        "method": "achat",
+        "span_name": "llamaindex.mistralai",
+        "wrapper_package": "wrap_common",
+        "wrapper_method": "allm_wrapper",
+        "output_processor": ["metamodel/maps/attributes/inference/llamaindex_entities.json"]
     }
 ]
-}
+}

monocle_apptrace/metamodel/spans/span_example.json

@@ -13,7 +13,7 @@
         "status_code": "OK"
     },
     "attributes": {
-        "span.type": "Retrieval", 
+        "span.type": "retrieval", 
         "entity.count": 2,
         "entity.1.name": "ChromaVectorStore",
         "entity.1.type": "vectorstore.chroma",

monocle_apptrace/metamodel/spans/span_types.json

@@ -0,0 +1,16 @@
+{
+    "span_types" : [
+        {
+            "type": "inference",
+            "description": "Model inference span"
+        },
+        {
+            "type": "retrieval",
+            "description": "vector embedding retrieval"
+        },
+        {
+            "type": "workflow",
+            "description": "workflow orchetraction at top level"
+        }
+    ]
+}

monocle_apptrace/utils.py

@@ -2,8 +2,14 @@ import logging
 import json
 from importlib import import_module
 import os
-from opentelemetry.trace import Span
-from monocle_apptrace.constants import azure_service_map, aws_service_map
+from opentelemetry.trace import NonRecordingSpan,Span
+from opentelemetry.trace.propagation import _SPAN_KEY
+from opentelemetry.context import (attach, detach,get_current)
+from opentelemetry.context import attach, set_value, get_value
+from monocle_apptrace.constants import service_name_map, service_type_map
+from json.decoder import JSONDecodeError
+
+logger = logging.getLogger(__name__)
 
 embedding_model_context = {}
 
@@ -21,12 +27,14 @@ def dont_throw(func):
     """
     # Obtain a logger specific to the function's module
     logger = logging.getLogger(func.__module__)
+
     # pylint: disable=inconsistent-return-statements
     def wrapper(*args, **kwargs):
         try:
             return func(*args, **kwargs)
         except Exception as ex:
             logger.warning("Failed to execute %s, error: %s", func.__name__, str(ex))
+
     return wrapper
 
 def with_tracer_wrapper(func):
@@ -34,8 +42,25 @@ def with_tracer_wrapper(func):
 
     def _with_tracer(tracer, to_wrap):
         def wrapper(wrapped, instance, args, kwargs):
-            return func(tracer, to_wrap, wrapped, instance, args, kwargs)
-
+            token = None
+            try:
+                _parent_span_context = get_current()
+                if _parent_span_context is not None and _parent_span_context.get(_SPAN_KEY, None):
+                    parent_span: Span = _parent_span_context.get(_SPAN_KEY, None)
+                    is_invalid_span = isinstance(parent_span, NonRecordingSpan)
+                    if is_invalid_span:
+                        token = attach(context={})
+            except Exception as e:
+                logger.error("Exception in attaching parent context: %s", e)
+
+            val = func(tracer, to_wrap, wrapped, instance, args, kwargs)
+            # Detach the token if it was set
+            if token:
+                try:
+                    detach(token=token)
+                except Exception as e:
+                    logger.error("Exception in detaching parent context: %s", e)
+            return val
         return wrapper
 
     return _with_tracer
@@ -48,32 +73,81 @@ def resolve_from_alias(my_map, alias):
             return my_map[i]
     return None
 
-def load_wrapper_from_config(config_file_path: str, module_name: str = None):
-    wrapper_methods = []
-    with open(config_file_path, encoding='UTF-8') as config_file:
+def load_output_processor(wrapper_method, attributes_config_base_path):
+    """Load the output processor from a file if the file path is provided and valid."""
+    logger = logging.getLogger()
+    output_processor_file_path = wrapper_method["output_processor"][0]
+    logger.info(f'Output processor file path is: {output_processor_file_path}')
+
+    if isinstance(output_processor_file_path, str) and output_processor_file_path:  # Combined condition
+        if not attributes_config_base_path:
+            absolute_file_path = os.path.abspath(output_processor_file_path)
+        else:
+            absolute_file_path = os.path.join(attributes_config_base_path, output_processor_file_path)
+
+        logger.info(f'Absolute file path is: {absolute_file_path}')
+        try:
+            with open(absolute_file_path, encoding='UTF-8') as op_file:
+                wrapper_method["output_processor"] = json.load(op_file)
+                logger.info('Output processor loaded successfully.')
+        except FileNotFoundError:
+            logger.error(f"Error: File not found at {absolute_file_path}.")
+        except JSONDecodeError:
+            logger.error(f"Error: Invalid JSON content in the file {absolute_file_path}.")
+        except Exception as e:
+            logger.error(f"Error: An unexpected error occurred: {e}")
+    else:
+        logger.error("Invalid or missing output processor file path.")
+
+def get_wrapper_methods_config(
+        wrapper_methods_config_path: str,
+        attributes_config_base_path: str = None
+):
+    parent_dir = os.path.dirname(os.path.join(os.path.dirname(__file__), '..'))
+    wrapper_methods_config = load_wrapper_methods_config_from_file(
+        wrapper_methods_config_path=os.path.join(parent_dir, wrapper_methods_config_path))
+    process_wrapper_method_config(
+        wrapper_methods_config=wrapper_methods_config,
+        attributes_config_base_path=attributes_config_base_path)
+    return wrapper_methods_config
+
+def load_wrapper_methods_config_from_file(
+        wrapper_methods_config_path: str):
+    json_data = {}
+
+    with open(wrapper_methods_config_path, encoding='UTF-8') as config_file:
         json_data = json.load(config_file)
-        wrapper_methods = json_data["wrapper_methods"]
-        for wrapper_method in wrapper_methods:
+
+    return json_data["wrapper_methods"]
+
+def process_wrapper_method_config(
+        wrapper_methods_config: str,
+        attributes_config_base_path: str = ""):
+    for wrapper_method in wrapper_methods_config:
+        if "wrapper_package" in wrapper_method and "wrapper_method" in wrapper_method:
             wrapper_method["wrapper"] = get_wrapper_method(
                 wrapper_method["wrapper_package"], wrapper_method["wrapper_method"])
-            if "span_name_getter_method" in wrapper_method :
+            if "span_name_getter_method" in wrapper_method:
                 wrapper_method["span_name_getter"] = get_wrapper_method(
                     wrapper_method["span_name_getter_package"],
                     wrapper_method["span_name_getter_method"])
-        return wrapper_methods
+        if "output_processor" in wrapper_method and wrapper_method["output_processor"]:
+            load_output_processor(wrapper_method, attributes_config_base_path)
 
 def get_wrapper_method(package_name: str, method_name: str):
     wrapper_module = import_module("monocle_apptrace." + package_name)
     return getattr(wrapper_module, method_name)
 
-def update_span_with_infra_name(span: Span, span_key: str):
-    for key,val  in azure_service_map.items():
-        if key in os.environ:
-            span.set_attribute(span_key, val)
-    for key,val  in aws_service_map.items():
-        if key in os.environ:
-            span.set_attribute(span_key, val)
-
+def set_app_hosting_identifier_attribute(span, span_index):
+    return_value = 0
+    # Search env to indentify the infra service type, if found check env for service name if possible
+    for type_env, type_name in service_type_map.items():
+        if type_env in os.environ:
+            return_value = 1
+            span.set_attribute(f"entity.{span_index}.type", f"app_hosting.{type_name}")
+            entity_name_env = service_name_map.get(type_name, "unknown")
+            span.set_attribute(f"entity.{span_index}.name", os.environ.get(entity_name_env, "generic"))
+    return return_value
 
 def set_embedding_model(model_name: str):
     """
@@ -83,7 +157,6 @@ def set_embedding_model(model_name: str):
     """
     embedding_model_context['embedding_model'] = model_name
 
-
 def get_embedding_model() -> str:
     """
     Retrieves the embedding model from the global context.
@@ -91,3 +164,89 @@ def get_embedding_model() -> str:
     @return: The name of the embedding model, or 'unknown' if not set
     """
     return embedding_model_context.get('embedding_model', 'unknown')
+
+def set_attribute(key: str, value: str):
+    """
+    Set a value in the global context for a given key.
+
+    Args:
+        key: The key for the context value to set.
+        value: The value to set for the given key.
+    """
+    attach(set_value(key, value))
+
+def get_attribute(key: str) -> str:
+    """
+    Retrieve a value from the global context for a given key.
+
+    Args:
+        key: The key for the context value to retrieve.
+
+    Returns:
+        The value associated with the given key.
+    """
+    return get_value(key)
+
+def flatten_dict(d, parent_key='', sep='_'):
+    items = []
+    for k, v in d.items():
+        new_key = f"{parent_key}{sep}{k}" if parent_key else k
+        if isinstance(v, dict):
+            items.extend(flatten_dict(v, new_key, sep=sep).items())
+        else:
+            items.append((new_key, v))
+    return dict(items)
+
+def get_fully_qualified_class_name(instance):
+    if instance is None:
+        return None
+    module_name = instance.__class__.__module__
+    qualname = instance.__class__.__qualname__
+    return f"{module_name}.{qualname}"
+
+# returns json path like key probe in a dictionary
+def get_nested_value(data, keys):
+    for key in keys:
+        if isinstance(data, dict) and key in data:
+            data = data[key]
+        elif hasattr(data, key):
+            data = getattr(data, key)
+        else:
+            return None
+    return data
+
+def get_workflow_name(span: Span) -> str:
+    try:
+        return get_value("workflow_name") or span.resource.attributes.get("service.name")
+    except Exception as e:
+        logger.exception(f"Error getting workflow name: {e}")
+        return None
+
+def get_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_keys_as_tuple(dictionary, *keys):
+    return tuple(next((value for key, value in dictionary.items() if key.endswith(k) and value is not None), None) for k in keys)
+
+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