monocle-apptrace 0.3.0b2__py3-none-any.whl → 0.3.0b3__py3-none-any.whl

monocle_apptrace/instrumentation/metamodel/llamaindex/_helper.py

@@ -0,0 +1,154 @@
+"""
+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_messages(args):
+    """Extract system and user messages"""
+    try:
+        messages = []
+        if args and isinstance(args, (list, tuple)) and args[0]:
+            for msg in args[0]:
+                if hasattr(msg, 'content') and hasattr(msg, 'role'):
+                    role = getattr(msg.role, 'value', msg.role)
+                    if role == "system":
+                        messages.append({role: msg.content})
+                    elif role in ["user", "human"]:
+                        user_message = extract_query_from_content(msg.content)
+                        messages.append({role: user_message})
+        if args and isinstance(args, dict):
+            for msg in args.get("messages", []):
+                if hasattr(msg, 'content') and hasattr(msg, 'role'):
+                    role = getattr(msg.role, 'value', msg.role)
+                    if role == "system":
+                        messages.append({role: msg.content})
+                    elif role in ["user", "human"]:
+                        user_message = msg.content
+                        messages.append({role: user_message})
+        return [str(message) for message in messages]
+    except Exception as e:
+        logger.warning("Warning: Error occurred 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]
+    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 None
+
+        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/inference.py

@@ -0,0 +1,71 @@
+from monocle_apptrace.instrumentation.metamodel.llamaindex import (
+    _helper,
+)
+from monocle_apptrace.instrumentation.common.utils import resolve_from_alias
+
+INFERENCE = {
+    "type": "inference",
+    "attributes": [
+        [
+            {
+                "_comment": "provider type ,name , deployment , inference_endpoint",
+                "attribute": "type",
+                "accessor": lambda arguments: 'inference.azure_oai'
+            },
+            {
+                "attribute": "provider_name",
+                "accessor": lambda arguments: _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'])
+                }
+            ]
+        }
+    ]
+}

monocle_apptrace/{metamodel/maps/llamaindex_methods.json → instrumentation/metamodel/llamaindex/methods.py}

@@ -1,92 +1,89 @@
-{
-"wrapper_methods" : [
+from monocle_apptrace.instrumentation.common.wrapper import atask_wrapper, task_wrapper
+from monocle_apptrace.instrumentation.metamodel.llamaindex.entities.inference import (
+    INFERENCE,
+)
+from monocle_apptrace.instrumentation.metamodel.llamaindex.entities.retrieval import (
+    RETRIEVAL,
+)
+
+
+LLAMAINDEX_METHODS = [
     {
         "package": "llama_index.core.indices.base_retriever",
         "object": "BaseRetriever",
         "method": "retrieve",
         "span_name": "llamaindex.retrieve",
-        "wrapper_package": "wrap_common",
-        "wrapper_method": "task_wrapper",
-        "output_processor": ["metamodel/maps/attributes/retrieval/llamaindex_entities.json"]
+        "wrapper_method": task_wrapper,
+        "output_processor": RETRIEVAL
     },
     {
         "package": "llama_index.core.indices.base_retriever",
         "object": "BaseRetriever",
         "method": "aretrieve",
         "span_name": "llamaindex.retrieve",
-        "wrapper_package": "wrap_common",
-        "wrapper_method": "atask_wrapper",
-        "output_processor": ["metamodel/maps/attributes/retrieval/llamaindex_entities.json"]
+        "wrapper_method": atask_wrapper,
+        "output_processor": RETRIEVAL
     },
     {
         "package": "llama_index.core.base.base_query_engine",
         "object": "BaseQueryEngine",
         "method": "query",
         "span_name": "llamaindex.query",
-        "wrapper_package": "wrap_common",
-        "wrapper_method": "task_wrapper"
+        "wrapper_method": task_wrapper
     },
     {
         "package": "llama_index.core.base.base_query_engine",
         "object": "BaseQueryEngine",
         "method": "aquery",
         "span_name": "llamaindex.query",
-        "wrapper_package": "wrap_common",
-        "wrapper_method": "atask_wrapper"
+        "wrapper_method": atask_wrapper
     },
     {
         "package": "llama_index.core.llms.custom",
         "object": "CustomLLM",
         "method": "chat",
         "span_name": "llamaindex.llmchat",
-        "wrapper_package": "wrap_common",
-        "wrapper_method": "task_wrapper",
-        "output_processor": ["metamodel/maps/attributes/inference/llamaindex_entities.json"]
+        "wrapper_method": task_wrapper,
+        "output_processor": INFERENCE
     },
     {
         "package": "llama_index.core.llms.custom",
         "object": "CustomLLM",
         "method": "achat",
         "span_name": "llamaindex.llmchat",
-        "wrapper_package": "wrap_common",
-        "wrapper_method": "atask_wrapper",
-        "output_processor": ["metamodel/maps/attributes/inference/llamaindex_entities.json"]
+        "wrapper_method": atask_wrapper,
+        "output_processor": INFERENCE
     },
     {
         "package": "llama_index.llms.openai.base",
         "object": "OpenAI",
         "method": "chat",
         "span_name": "llamaindex.openai",
-        "wrapper_package": "wrap_common",
-        "wrapper_method": "llm_wrapper",
-        "output_processor": ["metamodel/maps/attributes/inference/llamaindex_entities.json"]
+        "wrapper_method": task_wrapper,
+        "output_processor": INFERENCE
     },
     {
         "package": "llama_index.llms.openai.base",
         "object": "OpenAI",
         "method": "achat",
         "span_name": "llamaindex.openai",
-        "wrapper_package": "wrap_common",
-        "wrapper_method": "allm_wrapper",
-        "output_processor": ["metamodel/maps/attributes/inference/llamaindex_entities.json"]
+        "wrapper_method": atask_wrapper,
+        "output_processor": INFERENCE
     },
     {
         "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"]
+        "wrapper_method": task_wrapper,
+        "output_processor": INFERENCE
     },
     {
         "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"]
+        "wrapper_method": atask_wrapper,
+        "output_processor": INFERENCE
     }
 ]
-}

{monocle_apptrace-0.3.0b2.dist-info → monocle_apptrace-0.3.0b3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: monocle_apptrace
-Version: 0.3.0b2
+Version: 0.3.0b3
 Summary: package with monocle genAI tracing
 Project-URL: Homepage, https://github.com/monocle2ai/monocle
 Project-URL: Issues, https://github.com/monocle2ai/monocle/issues
@@ -20,22 +20,35 @@ 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: azure-storage-blob==12.22.0; extra == 'dev'
+Requires-Dist: boto3==1.34.131; extra == 'dev'
+Requires-Dist: chromadb==0.4.22; extra == 'dev'
 Requires-Dist: datasets==2.20.0; extra == 'dev'
 Requires-Dist: faiss-cpu==1.8.0; extra == 'dev'
+Requires-Dist: flask; extra == 'dev'
+Requires-Dist: haystack-ai==2.3.0; extra == 'dev'
 Requires-Dist: instructorembedding==1.0.1; extra == 'dev'
+Requires-Dist: langchain-aws==0.1.10; extra == 'dev'
 Requires-Dist: langchain-chroma==0.1.1; extra == 'dev'
 Requires-Dist: langchain-community==0.2.5; extra == 'dev'
 Requires-Dist: langchain-mistralai==0.1.13; extra == 'dev'
 Requires-Dist: langchain-openai==0.1.8; extra == 'dev'
 Requires-Dist: langchain==0.2.5; extra == 'dev'
+Requires-Dist: langchainhub==0.1.21; extra == 'dev'
 Requires-Dist: llama-index-embeddings-huggingface==0.2.0; extra == 'dev'
+Requires-Dist: llama-index-llms-azure-openai==0.1.9; extra == 'dev'
 Requires-Dist: llama-index-llms-mistralai==0.1.20; extra == 'dev'
 Requires-Dist: llama-index-vector-stores-chroma==0.1.9; extra == 'dev'
+Requires-Dist: llama-index-vector-stores-opensearch==0.1.10; extra == 'dev'
 Requires-Dist: llama-index==0.10.30; extra == 'dev'
 Requires-Dist: mistral-haystack==0.0.2; extra == 'dev'
 Requires-Dist: numpy==1.26.4; extra == 'dev'
+Requires-Dist: opendal==0.45.14; extra == 'dev'
+Requires-Dist: opensearch-haystack==1.2.0; extra == 'dev'
+Requires-Dist: opentelemetry-instrumentation-flask; extra == 'dev'
 Requires-Dist: parameterized==0.9.0; extra == 'dev'
 Requires-Dist: pytest==8.0.0; extra == 'dev'
+Requires-Dist: requests-aws4auth==1.2.3; extra == 'dev'
 Requires-Dist: sentence-transformers==2.6.1; extra == 'dev'
 Requires-Dist: types-requests==2.31.0.20240106; extra == 'dev'
 Description-Content-Type: text/markdown

monocle_apptrace-0.3.0b3.dist-info/RECORD

@@ -0,0 +1,48 @@
+monocle_apptrace/README.md,sha256=T5NFC01bF8VR0oVnAX_n0bhsEtttwqfTxDNAe5Y_ivE,3765
+monocle_apptrace/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+monocle_apptrace/exporters/base_exporter.py,sha256=Gov_QKp5fonVZ-YdNM2ynoPot7GCaSNmKbCHIP3bDlE,1680
+monocle_apptrace/exporters/exporter_processor.py,sha256=BTcBgMuFLHCdCgVvc9TKIo9y8g1BvShI0L4vX6Q-cmk,393
+monocle_apptrace/exporters/file_exporter.py,sha256=gN9pJ_X5pcstVVsyivgHsjWhr443eRa6Y6Hx1rGLQAM,2280
+monocle_apptrace/exporters/monocle_exporters.py,sha256=WRcRnnN0gSL7khN-BZ9wonMKiWaHNFqnBZ-QyM6hMsg,2177
+monocle_apptrace/exporters/aws/s3_exporter.py,sha256=eq5SfZmaeyhtXeXYnJGAfT1vlaNGSyh1leGX9Rr7vQ4,6619
+monocle_apptrace/exporters/aws/s3_exporter_opendal.py,sha256=FvyW0KkAz0W_1g16C_ERmamg4fSreT-UXgLaN9URTVQ,5057
+monocle_apptrace/exporters/azure/blob_exporter.py,sha256=m7Hsw3OXlP2GOCQcdxf8LM6Fe12fZmih45x82Z12dbI,5597
+monocle_apptrace/exporters/azure/blob_exporter_opendal.py,sha256=h5xv7JU6YEXL4AKT2B1op3YsHoA0rNnLCGq8seoVRWs,6114
+monocle_apptrace/exporters/okahu/okahu_exporter.py,sha256=p2rjStwo0OMEdHWQt_QvREpUWXbDm5jGx3qXeYai4_M,4407
+monocle_apptrace/instrumentation/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+monocle_apptrace/instrumentation/common/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+monocle_apptrace/instrumentation/common/constants.py,sha256=ySfwN5ZUtNFwm3ba5QWxBpLmZVuBRqVltuaBvpk-e3Y,1937
+monocle_apptrace/instrumentation/common/instrumentor.py,sha256=v79pmHDRf64G1Y0A6RMZlxbKizYRuNwlkJpRabESDiU,8386
+monocle_apptrace/instrumentation/common/span_handler.py,sha256=d5ycN3_OYkNm6_XKuAybMa-s1o6VrH92bEiR-Q_Hj24,7141
+monocle_apptrace/instrumentation/common/utils.py,sha256=nX3TErgaaYSlebYqQHuj4nqFyU51-nMrdIbQmO2vOTI,5357
+monocle_apptrace/instrumentation/common/wrapper.py,sha256=Q-7gyJpTtNpY1-khduT3vykvOewQ8qKzKQfYaZjho7s,2864
+monocle_apptrace/instrumentation/common/wrapper_method.py,sha256=rWiSdzhZrnWnNVVAZMetPboCH2HHSOZ7KgI7dPwGxV8,1629
+monocle_apptrace/instrumentation/metamodel/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+monocle_apptrace/instrumentation/metamodel/botocore/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+monocle_apptrace/instrumentation/metamodel/botocore/_helper.py,sha256=wK6yZ96csTOUaq5itQx0dS-vjDfyMu-AIPu3i3cXebs,4979
+monocle_apptrace/instrumentation/metamodel/botocore/methods.py,sha256=EYNYE8FolCoFgJU8q6Jkf_0CWDJ8kXIktX1eB5eTAIQ,404
+monocle_apptrace/instrumentation/metamodel/botocore/entities/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+monocle_apptrace/instrumentation/metamodel/botocore/entities/inference.py,sha256=JfTRmrxgU6e-b3dBbunWt5ObY_Ry_ZBYJBwKJB5UlJ8,2255
+monocle_apptrace/instrumentation/metamodel/haystack/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+monocle_apptrace/instrumentation/metamodel/haystack/_helper.py,sha256=VgTrKn7rZMcv4OVdVEBI76G-5B0Rux4guiI6Nsso14s,4833
+monocle_apptrace/instrumentation/metamodel/haystack/methods.py,sha256=4WwhZoPQBkV42TpBvn-rXu37xtaBRrw7_VZB3MGrfxE,1434
+monocle_apptrace/instrumentation/metamodel/haystack/entities/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+monocle_apptrace/instrumentation/metamodel/haystack/entities/inference.py,sha256=PkCaaar5hbZH7YGtWisq8dUJqBINsFGmtaUgt11UDa4,3019
+monocle_apptrace/instrumentation/metamodel/haystack/entities/retrieval.py,sha256=nq3lsk2qFxXqwrAHsBt8zrh4ZVGAJABkPtylrjUCCqc,2357
+monocle_apptrace/instrumentation/metamodel/langchain/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+monocle_apptrace/instrumentation/metamodel/langchain/_helper.py,sha256=7GixVwwzYR_Vcit1YN-xscA00HWFxOx7lcpqI94zi-w,4535
+monocle_apptrace/instrumentation/metamodel/langchain/methods.py,sha256=xEWO4uSiOnR221cvXESnVgAfC6JeExsP46ZkbK8_Yqs,3027
+monocle_apptrace/instrumentation/metamodel/langchain/entities/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+monocle_apptrace/instrumentation/metamodel/langchain/entities/inference.py,sha256=wjW9hb1Qwr_aqY0lPehdPftyHtuvHinGxVmy0TVj5xo,2705
+monocle_apptrace/instrumentation/metamodel/langchain/entities/retrieval.py,sha256=r4UqTCT5vOfkbz9lwoTRoiMkUUJtPMwqOYbqo53A6K8,2039
+monocle_apptrace/instrumentation/metamodel/llamaindex/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+monocle_apptrace/instrumentation/metamodel/llamaindex/_helper.py,sha256=PnxHbVP_XdXTelGYpWqlPvhR4Tr5QcaVd7hdJ0LuA3I,5854
+monocle_apptrace/instrumentation/metamodel/llamaindex/methods.py,sha256=THr-nmeGRNwmHaHeYxNLAG7EQOHZTwTYX-0EdFjfFBk,2748
+monocle_apptrace/instrumentation/metamodel/llamaindex/entities/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+monocle_apptrace/instrumentation/metamodel/llamaindex/entities/inference.py,sha256=585hJXbdN2kFOnABv12vlzFkCbDExZln5ISvQI71EHw,2623
+monocle_apptrace/instrumentation/metamodel/llamaindex/entities/retrieval.py,sha256=QBF1nrqog5KHh925jiY2V-kejL6iVLKUowZmqUDoiJ4,1870
+monocle_apptrace-0.3.0b3.dist-info/METADATA,sha256=VVAF6k-HKzOqIX05cguZz9fmkySu6CKpNWr8ynwRo8I,6265
+monocle_apptrace-0.3.0b3.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+monocle_apptrace-0.3.0b3.dist-info/licenses/LICENSE,sha256=ay9trLiP5I7ZsFXo6AqtkLYdRqe5S9r-DrPOvsNlZrg,9136
+monocle_apptrace-0.3.0b3.dist-info/licenses/NOTICE,sha256=9jn4xtwM_uUetJMx5WqGnhrR7MIhpoRlpokjSTlyt8c,112
+monocle_apptrace-0.3.0b3.dist-info/RECORD,,

monocle_apptrace/botocore/__init__.py

@@ -1,9 +0,0 @@
-import os
-from monocle_apptrace.utils import get_wrapper_methods_config
-
-parent_dir = os.path.abspath(os.path.join(os.path.dirname(__file__), '..'))
-BOTOCORE_METHODS = get_wrapper_methods_config(
-    wrapper_methods_config_path=os.path.join(parent_dir, 'metamodel', 'maps', 'botocore_methods.json'),
-    attributes_config_base_path=os.path.abspath(os.path.join(os.path.dirname(__file__), '..')))
-
-

monocle_apptrace/haystack/__init__.py

@@ -1,9 +0,0 @@
-import os
-import logging
-from monocle_apptrace.utils import get_wrapper_methods_config
-
-logger = logging.getLogger(__name__)
-parent_dir = os.path.abspath(os.path.join(os.path.dirname(__file__), '..'))
-HAYSTACK_METHODS = get_wrapper_methods_config(
-    wrapper_methods_config_path=os.path.join(parent_dir, 'metamodel', 'maps', 'haystack_methods.json'),
-    attributes_config_base_path=os.path.abspath(os.path.join(os.path.dirname(__file__), '..')))

monocle_apptrace/haystack/wrap_pipeline.py

@@ -1,63 +0,0 @@
-import logging
-from opentelemetry import context as context_api
-from opentelemetry.context import attach, set_value
-from opentelemetry.instrumentation.utils import (
-    _SUPPRESS_INSTRUMENTATION_KEY,
-)
-from monocle_apptrace.wrap_common import PROMPT_INPUT_KEY, PROMPT_OUTPUT_KEY, WORKFLOW_TYPE_MAP, with_tracer_wrapper, DATA_INPUT_KEY
-from monocle_apptrace.utils import set_embedding_model, set_attribute
-
-logger = logging.getLogger(__name__)
-
-
-@with_tracer_wrapper
-def wrap(tracer, to_wrap, wrapped, instance, args, kwargs):
-    if context_api.get_value(_SUPPRESS_INSTRUMENTATION_KEY):
-        return wrapped(*args, **kwargs)
-    name = "haystack_pipeline"
-    attach(set_value("workflow_name", name))
-    inputs = set()
-    workflow_input = get_workflow_input(args, inputs)
-    embedding_model = get_embedding_model(instance)
-    set_embedding_model(embedding_model)
-    set_attribute(DATA_INPUT_KEY, workflow_input)
-
-
-    with tracer.start_as_current_span(f"{name}.workflow") as span:
-        span.set_attribute(PROMPT_INPUT_KEY, workflow_input)
-        workflow_name = span.resource.attributes.get("service.name")
-        set_workflow_attributes(span, workflow_name)
-        response = wrapped(*args, **kwargs)
-        set_workflow_output(span, response)
-    return response
-
-def set_workflow_output(span, response):
-    workflow_output: str = response["llm"]["replies"][0]
-    span.set_attribute(PROMPT_OUTPUT_KEY, workflow_output)
-
-def get_workflow_input(args, inputs):
-    for value in args[0].values():
-        for text in value.values():
-            inputs.add(text)
-
-    workflow_input: str = ""
-
-    for input_str in inputs:
-        workflow_input = workflow_input + input_str
-    return workflow_input
-
-def set_workflow_attributes(span, workflow_name):
-    span.set_attribute("workflow_name",workflow_name)
-    span.set_attribute("workflow_type", WORKFLOW_TYPE_MAP["haystack"])
-
-def get_embedding_model(instance):
-    try:
-        if hasattr(instance, 'get_component'):
-            text_embedder = instance.get_component('text_embedder')
-            if text_embedder and hasattr(text_embedder, 'model'):
-                # Set the embedding model attribute
-                return text_embedder.model
-    except:
-        pass
-
-    return None