monocle-apptrace 0.1.0__py3-none-any.whl → 0.2.0__py3-none-any.whl

monocle_apptrace/wrap_common.py

@@ -1,24 +1,28 @@
-#pylint: disable=protected-access
+# pylint: disable=protected-access
 import logging
 import os
+import inspect
 from urllib.parse import urlparse
-
 from opentelemetry.trace import Span, Tracer
-from monocle_apptrace.utils import resolve_from_alias, update_span_with_infra_name, with_tracer_wrapper
-
+from monocle_apptrace.utils import resolve_from_alias, update_span_with_infra_name, with_tracer_wrapper, get_embedding_model, get_attribute, get_workflow_name
+from monocle_apptrace.utils import set_attribute
+from opentelemetry.context import get_value, attach, set_value
 logger = logging.getLogger(__name__)
 WORKFLOW_TYPE_KEY = "workflow_type"
-CONTEXT_INPUT_KEY = "context_input"
-CONTEXT_OUTPUT_KEY = "context_output"
-PROMPT_INPUT_KEY = "input"
-PROMPT_OUTPUT_KEY = "output"
+DATA_INPUT_KEY = "data.input"
+DATA_OUTPUT_KEY = "data.output"
+PROMPT_INPUT_KEY = "data.input"
+PROMPT_OUTPUT_KEY = "data.output"
 QUERY = "question"
 RESPONSE = "response"
-TAGS = "tags"
-CONTEXT_PROPERTIES_KEY = "workflow_context_properties"
+SESSION_PROPERTIES_KEY = "session"
 INFRA_SERVICE_KEY = "infra_service_name"
 
-
+TYPE = "type"
+PROVIDER = "provider_name"
+EMBEDDING_MODEL = "embedding_model"
+VECTOR_STORE = 'vector_store'
+META_DATA = 'metadata'
 
 WORKFLOW_TYPE_MAP = {
     "llama_index": "workflow.llamaindex",
@@ -26,6 +30,53 @@ WORKFLOW_TYPE_MAP = {
     "haystack": "workflow.haystack"
 }
 
+def get_embedding_model_for_vectorstore(instance):
+    # Handle Langchain or other frameworks where vectorstore exists
+    if hasattr(instance, 'vectorstore'):
+        vectorstore_dict = instance.vectorstore.__dict__
+
+        # Use inspect to check if the embedding function is from Sagemaker
+        if 'embedding_func' in vectorstore_dict:
+            embedding_func = vectorstore_dict['embedding_func']
+            class_name = embedding_func.__class__.__name__
+            file_location = inspect.getfile(embedding_func.__class__)
+
+            # Check if the class is SagemakerEndpointEmbeddings
+            if class_name == 'SagemakerEndpointEmbeddings' and 'langchain_community' in file_location:
+                # Set embedding_model as endpoint_name if it's Sagemaker
+                if hasattr(embedding_func, 'endpoint_name'):
+                    return embedding_func.endpoint_name
+
+        # Default to the regular embedding model if not Sagemaker
+        return instance.vectorstore.embeddings.model
+
+    # Handle llama_index where _embed_model is present
+    if hasattr(instance, '_embed_model') and hasattr(instance._embed_model, 'model_name'):
+        return instance._embed_model.model_name
+
+    # Fallback if no specific model is found
+    return "Unknown Embedding Model"
+
+
+framework_vector_store_mapping = {
+    'langchain_core.retrievers': lambda instance: {
+        'provider': type(instance.vectorstore).__name__,
+        'embedding_model': get_embedding_model_for_vectorstore(instance),
+        'type': VECTOR_STORE,
+    },
+    'llama_index.core.indices.base_retriever': lambda instance: {
+        'provider': type(instance._vector_store).__name__,
+        'embedding_model': get_embedding_model_for_vectorstore(instance),
+        'type': VECTOR_STORE,
+    },
+    'haystack.components.retrievers.in_memory': lambda instance: {
+        'provider': instance.__dict__.get("document_store").__class__.__name__,
+        'embedding_model': get_embedding_model(),
+        'type': VECTOR_STORE,
+    },
+}
+
+
 @with_tracer_wrapper
 def task_wrapper(tracer: Tracer, to_wrap, wrapped, instance, args, kwargs):
     """Instruments and calls every function defined in TO_WRAP."""
@@ -42,34 +93,82 @@ def task_wrapper(tracer: Tracer, to_wrap, wrapped, instance, args, kwargs):
         name = f"langchain.task.{instance.__class__.__name__}"
 
     with tracer.start_as_current_span(name) as span:
+        process_span(to_wrap, span, instance, args)
         pre_task_processing(to_wrap, instance, args, span)
         return_value = wrapped(*args, **kwargs)
         post_task_processing(to_wrap, span, return_value)
 
     return return_value
 
-def post_task_processing(to_wrap, span, return_value):
-    update_span_with_context_output(to_wrap=to_wrap, return_value=return_value, span=span)
 
+def process_span(to_wrap, span, instance, args):
+    # Check if the output_processor is a valid JSON (in Python, that means it's a dictionary)
+    span_index = 1
     if is_root_span(span):
-        workflow_name = span.resource.attributes.get("service.name")
-        span.set_attribute("workflow_name",workflow_name)
-        update_span_with_prompt_output(to_wrap=to_wrap, wrapped_args=return_value, span=span)
-        update_workflow_type(to_wrap, span)
+        workflow_name = get_workflow_name(span)
+        if workflow_name:
+            span.set_attribute(f"entity.{span_index}.name", workflow_name)
+        # workflow type
+        package_name = to_wrap.get('package')
+        for (package, workflow_type) in WORKFLOW_TYPE_MAP.items():
+            if (package_name is not None and package in package_name):
+                span.set_attribute(f"entity.{span_index}.type", workflow_type)
+        span_index += 1
+    if 'output_processor' in to_wrap:
+        output_processor=to_wrap['output_processor']
+        if isinstance(output_processor, dict) and len(output_processor) > 0:
+            if 'type' in output_processor:
+                span.set_attribute("span.type", output_processor['type'])
+            else:
+                logger.warning("type of span not found or incorrect written in entity json")
+            count = 0
+            if 'attributes' in output_processor:
+                count = len(output_processor["attributes"])
+                span.set_attribute("entity.count", count)
+                span_index = 1
+                for processors in output_processor["attributes"]:
+                    for processor in processors:
+                        attribute = processor.get('attribute')
+                        accessor = processor.get('accessor')
+
+                        if attribute and accessor:
+                            attribute_name = f"entity.{span_index}.{attribute}"
+                            try:
+                                result = eval(accessor)(instance, args)
+                                if result and isinstance(result, str):
+                                    span.set_attribute(attribute_name, result)
+                            except Exception as e:
+                                logger.error(f"Error processing accessor: {e}")
+                        else:
+                            logger.warning(f"{' and '.join([key for key in ['attribute', 'accessor'] if not processor.get(key)])} not found or incorrect in entity JSON")
+                    span_index += 1
+            else:
+                logger.warning("attributes not found or incorrect written in entity json")
+                span.set_attribute("span.count", count)
+
+        else:
+            logger.warning("empty or entities json is not in correct format")
 
-def pre_task_processing(to_wrap, instance, args, span):
-    if is_root_span(span):
-        update_span_with_prompt_input(to_wrap=to_wrap, wrapped_args=args, span=span)
 
-        update_span_with_infra_name(span, INFRA_SERVICE_KEY)
+def post_task_processing(to_wrap, span, return_value):
+    try:
+        update_span_with_context_output(to_wrap=to_wrap, return_value=return_value, span=span)
 
-    #capture the tags attribute of the instance if present, else ignore
+        if is_root_span(span):
+            update_span_with_prompt_output(to_wrap=to_wrap, wrapped_args=return_value, span=span)
+    except:
+        logger.exception("exception in post_task_processing")
+
+
+def pre_task_processing(to_wrap, instance, args, span):
     try:
-        update_tags(instance, span)
-    except AttributeError:
-        pass
-    update_span_with_context_input(to_wrap=to_wrap, wrapped_args=args, span=span)
+        if is_root_span(span):
+            update_span_with_prompt_input(to_wrap=to_wrap, wrapped_args=args, span=span)
+            update_span_with_infra_name(span, INFRA_SERVICE_KEY)
 
+        update_span_with_context_input(to_wrap=to_wrap, wrapped_args=args, span=span)
+    except:
+        logger.exception("exception in pre_task_processing")
 
 
 @with_tracer_wrapper
@@ -87,12 +186,14 @@ async def atask_wrapper(tracer, to_wrap, wrapped, instance, args, kwargs):
     else:
         name = f"langchain.task.{instance.__class__.__name__}"
     with tracer.start_as_current_span(name) as span:
+        process_span(to_wrap, span, instance, args)
         pre_task_processing(to_wrap, instance, args, span)
         return_value = await wrapped(*args, **kwargs)
         post_task_processing(to_wrap, span, return_value)
 
     return return_value
 
+
 @with_tracer_wrapper
 async def allm_wrapper(tracer, to_wrap, wrapped, instance, args, kwargs):
     # Some Langchain objects are wrapped elsewhere, so we ignore them here
@@ -109,16 +210,24 @@ async def allm_wrapper(tracer, to_wrap, wrapped, instance, args, kwargs):
     else:
         name = f"langchain.task.{instance.__class__.__name__}"
     with tracer.start_as_current_span(name) as span:
-        update_llm_endpoint(curr_span= span, instance=instance)
+        if 'haystack.components.retrievers' in to_wrap['package'] and 'haystack.retriever' in span.name:
+            input_arg_text = get_attribute(DATA_INPUT_KEY)
+            span.add_event(DATA_INPUT_KEY, {QUERY: input_arg_text})
+        provider_name, inference_endpoint = get_provider_name(instance)
+        instance_args = {"provider_name": provider_name, "inference_endpoint": inference_endpoint}
+
+        process_span(to_wrap, span, instance, instance_args)
 
         return_value = await wrapped(*args, **kwargs)
-        update_span_from_llm_response(response = return_value, span = span)
+        if 'haystack.components.retrievers' in to_wrap['package'] and 'haystack.retriever' in span.name:
+            update_span_with_context_output(to_wrap=to_wrap, return_value=return_value, span=span)
+        update_span_from_llm_response(response=return_value, span=span, instance=instance)
 
     return return_value
 
+
 @with_tracer_wrapper
 def llm_wrapper(tracer: Tracer, to_wrap, wrapped, instance, args, kwargs):
-
     # Some Langchain objects are wrapped elsewhere, so we ignore them here
     if instance.__class__.__name__ in ("AgentExecutor"):
         return wrapped(*args, **kwargs)
@@ -132,86 +241,121 @@ def llm_wrapper(tracer: Tracer, to_wrap, wrapped, instance, args, kwargs):
         name = to_wrap.get("span_name")
     else:
         name = f"langchain.task.{instance.__class__.__name__}"
+
     with tracer.start_as_current_span(name) as span:
-        update_llm_endpoint(curr_span= span, instance=instance)
+        if 'haystack.components.retrievers' in to_wrap['package'] and 'haystack.retriever' in span.name:
+            input_arg_text = get_attribute(DATA_INPUT_KEY)
+            span.add_event(DATA_INPUT_KEY, {QUERY: input_arg_text})
+        provider_name, inference_endpoint = get_provider_name(instance)
+        instance_args = {"provider_name": provider_name, "inference_endpoint": inference_endpoint}
+
+        process_span(to_wrap, span, instance, instance_args)
 
         return_value = wrapped(*args, **kwargs)
-        update_span_from_llm_response(response = return_value, span = span)
+        if 'haystack.components.retrievers' in to_wrap['package'] and 'haystack.retriever' in span.name:
+            update_span_with_context_output(to_wrap=to_wrap, return_value=return_value, span=span)
+        update_span_from_llm_response(response=return_value, span=span, instance=instance)
 
     return return_value
 
+
 def update_llm_endpoint(curr_span: Span, instance):
+    # Lambda to set attributes if values are not None
+    __set_span_attribute_if_not_none = lambda span, **kwargs: [
+        span.set_attribute(k, v) for k, v in kwargs.items() if v is not None
+    ]
+
     triton_llm_endpoint = os.environ.get("TRITON_LLM_ENDPOINT")
     if triton_llm_endpoint is not None and len(triton_llm_endpoint) > 0:
         curr_span.set_attribute("server_url", triton_llm_endpoint)
     else:
-        if 'temperature' in instance.__dict__:
-            temp_val = instance.__dict__.get("temperature")
-            curr_span.set_attribute("temperature", temp_val)
-        # handling for model name
-        model_name =  resolve_from_alias(instance.__dict__ , ["model","model_name"])
-        curr_span.set_attribute("model_name", model_name)
-        set_provider_name(curr_span, instance)
-        # handling AzureOpenAI deployment
-        deployment_name =  resolve_from_alias(instance.__dict__ , [ "engine", "azure_deployment",
-                                                                   "deployment_name", "deployment_id", "deployment"])
-        curr_span.set_attribute("az_openai_deployment", deployment_name)
-        # handling the inference endpoint
-        inference_ep = resolve_from_alias(instance.__dict__,["azure_endpoint","api_base"])
-        curr_span.set_attribute("inference_endpoint",inference_ep)
-
-def set_provider_name(curr_span, instance):
+        # Get temperature if present
+        temp_val = instance.__dict__.get("temperature")
+
+        # Resolve values for model name, deployment, and inference endpoint
+        model_name = resolve_from_alias(instance.__dict__, ["model", "model_name"])
+        deployment_name = resolve_from_alias(instance.__dict__,
+                                             ["engine", "azure_deployment", "deployment_name", "deployment_id",
+                                              "deployment"])
+        inference_ep = resolve_from_alias(instance.__dict__, ["azure_endpoint", "api_base"])
+
+        # Use the lambda to set attributes conditionally
+        __set_span_attribute_if_not_none(
+            curr_span,
+            temperature=temp_val,
+            model_name=model_name,
+            az_openai_deployment=deployment_name,
+            inference_endpoint=inference_ep
+        )
+
+
+def get_provider_name(instance):
     provider_url = ""
-
-    try :
-        if isinstance(instance.client._client.base_url.host, str) :
-            provider_url = instance. client._client.base_url.host
+    inference_endpoint = ""
+    try:
+        if isinstance(instance.client._client.base_url.host, str):
+            provider_url = instance.client._client.base_url.host
+        if isinstance(instance.client._client.base_url, str):
+            inference_endpoint = instance.client._client.base_url
+        else:
+            inference_endpoint = str(instance.client._client.base_url)
     except:
         pass
 
-    try :
+    try:
         if isinstance(instance.api_base, str):
             provider_url = instance.api_base
     except:
         pass
 
-    try :
+    try:
         if len(provider_url) > 0:
             parsed_provider_url = urlparse(provider_url)
-            curr_span.set_attribute("provider_name", parsed_provider_url.hostname or provider_url)
     except:
         pass
+    return parsed_provider_url.hostname or provider_url,inference_endpoint
+
 
 def is_root_span(curr_span: Span) -> bool:
     return curr_span.parent is None
 
+
 def get_input_from_args(chain_args):
     if len(chain_args) > 0 and isinstance(chain_args[0], str):
         return chain_args[0]
     return ""
 
-def update_span_from_llm_response(response, span: Span):
-    
+
+def update_span_from_llm_response(response, span: Span, instance):
     # extract token uasge from langchain openai
     if (response is not None and hasattr(response, "response_metadata")):
         response_metadata = response.response_metadata
         token_usage = response_metadata.get("token_usage")
+        meta_dict = {}
         if token_usage is not None:
-            span.set_attribute("completion_tokens", token_usage.get("completion_tokens"))
-            span.set_attribute("prompt_tokens", token_usage.get("prompt_tokens"))
-            span.set_attribute("total_tokens", token_usage.get("total_tokens"))
+            temperature = instance.__dict__.get("temperature", None)
+            meta_dict.update({"temperature": temperature})
+            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")})
+            span.add_event(META_DATA, meta_dict)
     # extract token usage from llamaindex openai
-    if(response is not None and hasattr(response, "raw")):
+    if (response is not None and hasattr(response, "raw")):
         try:
+            meta_dict = {}
             if response.raw is not None:
-                token_usage = response.raw.get("usage") if isinstance(response.raw, dict) else getattr(response.raw, "usage", 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):
-                        span.set_attribute("completion_tokens", getattr(token_usage, "completion_tokens"))
+                        meta_dict.update({"completion_tokens": getattr(token_usage, "completion_tokens")})
                     if getattr(token_usage, "prompt_tokens", None):
-                        span.set_attribute("prompt_tokens", getattr(token_usage, "prompt_tokens"))
+                        meta_dict.update({"prompt_tokens": getattr(token_usage, "prompt_tokens")})
                     if getattr(token_usage, "total_tokens", None):
-                        span.set_attribute("total_tokens", getattr(token_usage, "total_tokens"))
+                        meta_dict.update({"total_tokens": getattr(token_usage, "total_tokens")})
+                    span.add_event(META_DATA, meta_dict)
         except AttributeError:
             token_usage = None
 
@@ -220,49 +364,54 @@ def update_workflow_type(to_wrap, span: Span):
     package_name = to_wrap.get('package')
 
     for (package, workflow_type) in WORKFLOW_TYPE_MAP.items():
-        if(package_name is not None and package in package_name):
+        if (package_name is not None and package in package_name):
             span.set_attribute(WORKFLOW_TYPE_KEY, workflow_type)
 
-def update_span_with_context_input(to_wrap, wrapped_args ,span: Span):
-    package_name: str = to_wrap.get('package')
-    if "langchain_core.retrievers" in package_name:
-        input_arg_text = wrapped_args[0]
-        span.add_event(CONTEXT_INPUT_KEY, {QUERY:input_arg_text})
-    if "llama_index.core.indices.base_retriever" in package_name:
-        input_arg_text = wrapped_args[0].query_str
-        span.add_event(CONTEXT_INPUT_KEY, {QUERY:input_arg_text})
 
-def update_span_with_context_output(to_wrap, return_value ,span: Span):
+def update_span_with_context_input(to_wrap, wrapped_args, span: Span):
     package_name: str = to_wrap.get('package')
-    if "llama_index.core.indices.base_retriever" in package_name:
-        output_arg_text = return_value[0].text
-        span.add_event(CONTEXT_OUTPUT_KEY, {RESPONSE:output_arg_text})
-
-def update_span_with_prompt_input(to_wrap, wrapped_args ,span: Span):
+    input_arg_text = ""
+    if "langchain_core.retrievers" in package_name and len(wrapped_args) > 0:
+        input_arg_text += wrapped_args[0]
+    if "llama_index.core.indices.base_retriever" in package_name and len(wrapped_args) > 0:
+        input_arg_text += wrapped_args[0].query_str
+    if "haystack.components.retrievers.in_memory" in package_name:
+        input_arg_text += get_attribute(DATA_INPUT_KEY)
+    if input_arg_text:
+        span.add_event(DATA_INPUT_KEY, {QUERY: input_arg_text})
+
+
+def update_span_with_context_output(to_wrap, return_value, span: Span):
+    package_name: str = to_wrap.get('package')
+    output_arg_text = ""
+    if "langchain_core.retrievers" in package_name:
+        output_arg_text += " ".join([doc.page_content for doc in return_value if hasattr(doc, 'page_content')])
+        if len(output_arg_text) > 100:
+            output_arg_text = output_arg_text[:100] + "..."
+    if "llama_index.core.indices.base_retriever" in package_name and len(return_value) > 0:
+        output_arg_text += return_value[0].text
+    if "haystack.components.retrievers.in_memory" in package_name:
+        output_arg_text += " ".join([doc.content for doc in return_value['documents']])
+        if len(output_arg_text) > 100:
+            output_arg_text = output_arg_text[:100] + "..."
+    if output_arg_text:
+        span.add_event(DATA_OUTPUT_KEY, {RESPONSE: output_arg_text})
+
+
+def update_span_with_prompt_input(to_wrap, wrapped_args, span: Span):
     input_arg_text = wrapped_args[0]
 
     if isinstance(input_arg_text, dict):
-        span.add_event(PROMPT_INPUT_KEY,input_arg_text)
+        span.add_event(PROMPT_INPUT_KEY, input_arg_text)
     else:
-        span.add_event(PROMPT_INPUT_KEY,{QUERY:input_arg_text})
+        span.add_event(PROMPT_INPUT_KEY, {QUERY: input_arg_text})
 
-def update_span_with_prompt_output(to_wrap, wrapped_args ,span: Span):
+
+def update_span_with_prompt_output(to_wrap, wrapped_args, span: Span):
     package_name: str = to_wrap.get('package')
     if isinstance(wrapped_args, str):
-        span.add_event(PROMPT_OUTPUT_KEY, {RESPONSE:wrapped_args})
+        span.add_event(PROMPT_OUTPUT_KEY, {RESPONSE: wrapped_args})
+    if isinstance(wrapped_args, dict):
+        span.add_event(PROMPT_OUTPUT_KEY, wrapped_args)
     if "llama_index.core.base.base_query_engine" in package_name:
-        span.add_event(PROMPT_OUTPUT_KEY, {RESPONSE:wrapped_args.response})
-
-def update_tags(instance, span):
-    try:
-        # copy tags as is from langchain
-        span.set_attribute(TAGS, getattr(instance, TAGS))
-    except:
-        pass
-    try:
-        # extract embed model and vector store names for llamaindex
-        model_name = instance.retriever._embed_model.model_name
-        vector_store_name = type(instance.retriever._vector_store).__name__
-        span.set_attribute(TAGS, [model_name, vector_store_name])
-    except:
-        pass
+        span.add_event(PROMPT_OUTPUT_KEY, {RESPONSE: wrapped_args.response})

monocle_apptrace/wrapper.py

@@ -1,5 +1,4 @@
 
-
 from monocle_apptrace.haystack import HAYSTACK_METHODS
 from monocle_apptrace.langchain import LANGCHAIN_METHODS
 from monocle_apptrace.llamaindex import LLAMAINDEX_METHODS
@@ -13,12 +12,15 @@ class WrapperMethod:
             object_name: str,
             method: str,
             span_name: str = None,
+            output_processor : list[str] = None,
             wrapper = task_wrapper
             ):
         self.package = package
         self.object = object_name
         self.method = method
         self.span_name = span_name
+        self.output_processor=output_processor
+
         self.wrapper = wrapper
 
 INBUILT_METHODS_LIST = LANGCHAIN_METHODS + LLAMAINDEX_METHODS + HAYSTACK_METHODS

monocle_apptrace-0.2.0.dist-info/METADATA

@@ -0,0 +1,115 @@
+Metadata-Version: 2.3
+Name: monocle_apptrace
+Version: 0.2.0
+Summary: package with monocle genAI tracing
+Project-URL: Homepage, https://github.com/monocle2ai/monocle
+Project-URL: Issues, https://github.com/monocle2ai/monocle/issues
+License-File: LICENSE
+License-File: NOTICE
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.8
+Requires-Dist: opentelemetry-api>=1.21.0
+Requires-Dist: opentelemetry-instrumentation
+Requires-Dist: opentelemetry-sdk>=1.21.0
+Requires-Dist: requests
+Requires-Dist: wrapt>=1.14.0
+Provides-Extra: aws
+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: datasets==2.20.0; extra == 'dev'
+Requires-Dist: faiss-cpu==1.8.0; extra == 'dev'
+Requires-Dist: instructorembedding==1.0.1; extra == 'dev'
+Requires-Dist: langchain-chroma==0.1.1; extra == 'dev'
+Requires-Dist: langchain-community==0.2.5; extra == 'dev'
+Requires-Dist: langchain-openai==0.1.8; extra == 'dev'
+Requires-Dist: langchain==0.2.5; extra == 'dev'
+Requires-Dist: llama-index-embeddings-huggingface==0.2.0; extra == 'dev'
+Requires-Dist: llama-index-vector-stores-chroma==0.1.9; extra == 'dev'
+Requires-Dist: llama-index==0.10.30; extra == 'dev'
+Requires-Dist: numpy==1.26.4; extra == 'dev'
+Requires-Dist: parameterized==0.9.0; extra == 'dev'
+Requires-Dist: pytest==8.0.0; 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 for tracing GenAI app code
+
+**Monocle** helps developers and platform engineers building or managing GenAI apps monitor these in prod by making it easy to instrument their code to capture traces that are compliant with open-source cloud-native observability ecosystem. 
+
+**Monocle** is a community-driven OSS framework for tracing GenAI app code governed as a [Linux Foundation AI & Data project](https://lfaidata.foundation/projects/monocle/). 
+
+## Why Monocle
+
+Monocle is built for: 
+- **app developers** to trace their app code in any environment without lots of custom code decoration 
+- **platform engineers** to instrument apps in prod through wrapping instead of asking app devs to recode
+- **GenAI component providers** to add observability features to their products 
+- **enterprises** to consume traces from GenAI apps in their existing open-source observability stack
+
+Benefits:
+- Monocle provides an implementation + package, not just a spec 
+   - No expertise in OpenTelemetry spec required
+   - No bespoke implementation of that spec required
+   - No last-mile GenAI domain specific code required to instrument your app
+- Monocle provides consistency  
+   - Connect traces across app code executions, model inference or data retrievals
+   - No cleansing of telemetry data across GenAI component providers required
+   - Works the same in personal lab dev or org cloud prod environments
+   - Send traces to location that fits your scale, budget and observability stack
+- Monocle is fully open source and community driven
+   - No vendor lock-in
+   - Implementation is transparent
+   - You can freely use or customize it to fit your needs 
+
+## What Monocle provides
+
+- Easy to [use](#use-monocle) code instrumentation
+- OpenTelemetry compatible format for [spans](src/monocle_apptrace/metamodel/spans/span_format.json). 
+- Community-curated and extensible [metamodel](src/monocle_apptrace/metamodel/README.md) for consisent tracing of GenAI components. 
+- Export to local and cloud storage 
+
+## Use Monocle
+
+- Get the Monocle package
+  
+```
+    pip install monocle_apptrace 
+```
+- Instrument your app code
+     - Import the Monocle package
+       ```
+          from monocle_apptrace.instrumentor import setup_monocle_telemetry
+       ```
+     - Setup instrumentation in your ```main()``` function  
+       ``` 
+          setup_monocle_telemetry(workflow_name="your-app-name")
+       ```         
+- (Optionally) Modify config to alter where traces are sent
+
+See [Monocle user guide](Monocle_User_Guide.md) for more details.
+  
+
+## Roadmap 
+
+Goal of Monocle is to support tracing for apps written in *any language* with *any LLM orchestration or agentic framework* and built using models, vectors, agents or other components served up by *any cloud or model inference provider*. 
+
+Current version supports: 
+- Language: (🟢) Python , (🔜) [Typescript](https://github.com/monocle2ai/monocle-typescript) 
+- LLM-frameworks: (🟢) Langchain, (🟢) Llamaindex, (🟢) Haystack, (🔜) Flask
+- LLM inference providers: (🟢) OpenAI, (🟢) Azure OpenAI, (🟢) Nvidia Triton, (🔜) AWS Bedrock, (🔜) Google Vertex, (🔜) Azure ML, (🔜) Hugging Face
+- Vector stores: (🟢) FAISS, (🔜) OpenSearch, (🔜) Milvus
+- Exporter: (🟢) stdout, (🟢) file, (🔜) Azure Blob Storage, (🔜) AWS S3, (🔜) Google Cloud Storage
+
+
+## Get involved
+### Provide feedback
+- Submit issues and enhancements requests via Github issues
+
+### Contribute
+- Monocle is community based open source project. We welcome your contributions. Please refer to the CONTRIBUTING and CODE_OF_CONDUCT for guidelines. The [contributor's guide](CONTRIBUTING.md) provides technical details of the project.
+

monocle_apptrace-0.2.0.dist-info/RECORD

@@ -0,0 +1,44 @@
+monocle_apptrace/README.md,sha256=T5NFC01bF8VR0oVnAX_n0bhsEtttwqfTxDNAe5Y_ivE,3765
+monocle_apptrace/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+monocle_apptrace/constants.py,sha256=wjObbmMTFL201x-bf3EOXevYygwkFH_1ng5dDrpE3z0,810
+monocle_apptrace/instrumentor.py,sha256=FMQ8yVNYGRBTmyUjC2578G8RzSRpHY5HtVN5WK9ndVE,5291
+monocle_apptrace/utils.py,sha256=l-affXaMX6U_wG1rWRE2GPB6dDGtha7kL0MQK4PEptI,6395
+monocle_apptrace/wrap_common.py,sha256=ux2Ob7g1FYDtt1gF4g8XKQhl6Ed5X_iR4CP4GHX4upM,18178
+monocle_apptrace/wrapper.py,sha256=8bsMaCCCbaEJN8hW5YoYkn2XLJ7vFI1HJk6QHihbkto,830
+monocle_apptrace/exporters/base_exporter.py,sha256=1UvywEiKZ0nilcXiy-mZue012yVvYXgwib1x1qQvpBc,1647
+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=mvVoGr4itvUBuakH17zNEuXYpHtqRhq2CBH5JXhleoM,1418
+monocle_apptrace/exporters/aws/s3_exporter.py,sha256=S_w2OBkM8eEYK6bBDbfcRV4LdojU1QygOBqjdhcjAl4,6730
+monocle_apptrace/exporters/azure/blob_exporter.py,sha256=dtL8MPISyP1eKM0gGpSoqTUmFuGEfycqF9OCjFF6H6E,5716
+monocle_apptrace/exporters/okahu/okahu_exporter.py,sha256=p2rjStwo0OMEdHWQt_QvREpUWXbDm5jGx3qXeYai4_M,4407
+monocle_apptrace/haystack/__init__.py,sha256=zMvF6Dh1-vVIAQD__HC1ubT5bs-EupUghg7HNhDv7_c,448
+monocle_apptrace/haystack/wrap_node.py,sha256=IK07Wn3Lk1Os9URsyrmB1HXOH2FNdzK9fNLlR8TZdYc,908
+monocle_apptrace/haystack/wrap_openai.py,sha256=Yp916DhOl0WI6virRi3L43snfsQm7PhI28wlDsg19v8,1536
+monocle_apptrace/haystack/wrap_pipeline.py,sha256=yZAw7Hdv7FXe6rrM7gA2y5SjaZYQZCAi0q-R-uqUEvk,2254
+monocle_apptrace/langchain/__init__.py,sha256=3yhbdw1h9I1nVEfnOOPKz9yD5NqwdLSZsxtXbMplRkw,400
+monocle_apptrace/llamaindex/__init__.py,sha256=TgV1ZM8Cz113pZ2aAgpYwsCJyHA2aHOvNoW1QMBp0mM,709
+monocle_apptrace/metamodel/README.md,sha256=KYuuYqgA9PNbOjG0zYj2nAdvNEpyNN_Bk9M2tNdnZ_s,4598
+monocle_apptrace/metamodel/entities/README.md,sha256=dY7Q8QT_Ju-2ul65J-k0x6beDLvRirlbGufZN1Q0tpk,2068
+monocle_apptrace/metamodel/entities/app_hosting_types.json,sha256=MWeHUe77n4HvO1hm2PX8iWjbRONBuNy2I84vd-lymYk,568
+monocle_apptrace/metamodel/entities/entities.json,sha256=6eDoDm_6aPUgH_ROjI2H9Tk3J5Lj55VkX3Li-TJmaxg,1285
+monocle_apptrace/metamodel/entities/inference_types.json,sha256=Gkq7qNw5Qn91tuq-rBxHJ4BSzT-etCshNjT5_G4Bg8I,651
+monocle_apptrace/metamodel/entities/model_types.json,sha256=Oz9DzuX_ptpLEVTc1Epv4_Y80TrYxR7cyc9kM0Zk780,785
+monocle_apptrace/metamodel/entities/vector_store_types.json,sha256=EA0KayHMOG7wMIkec54en03_3yT1qpdGh5TiDrAoh4g,462
+monocle_apptrace/metamodel/entities/workflow_types.json,sha256=eD0W3_FocKrzrrW0bks0hIJb9Kj7w8c1dpXzxmGLOwk,386
+monocle_apptrace/metamodel/maps/haystack_methods.json,sha256=JmngkaKICAzOyrWNTWEOLYFrp99l5wcERYKE_SQRNxE,698
+monocle_apptrace/metamodel/maps/langchain_methods.json,sha256=lfU8nd6td5qzTI01glM063Vg0UoZM9HGPirwN4OZcKc,4285
+monocle_apptrace/metamodel/maps/llamaindex_methods.json,sha256=pZ4d1DS4D6Wgpz9EBOrEuJUFN58jtu75E8ELyGRBHyM,2636
+monocle_apptrace/metamodel/maps/attributes/inference/langchain_entities.json,sha256=E_K3eHv_e9Va2AcjNLHcXeAgePB1uolTMdRnkxxtNqU,1152
+monocle_apptrace/metamodel/maps/attributes/inference/llamaindex_entities.json,sha256=LuAa9ZKl3mO2VUiXMVGZNEfSHOZ0n5qsVQLqWRHczVM,1122
+monocle_apptrace/metamodel/maps/attributes/retrieval/langchain_entities.json,sha256=vSe2kbeJ7izmj5TBdQpX5pJ3hbjdY4SkcXvWPiam7oo,718
+monocle_apptrace/metamodel/maps/attributes/retrieval/llamaindex_entities.json,sha256=BtWeSXUPzKR9-vuhZUUhn2Gz9Y4SXBZoFC81K1q0XwQ,712
+monocle_apptrace/metamodel/spans/README.md,sha256=_uMkLLaWitQ_rPh7oQbW5Oe7uGSv2h_QA6YwxHRJi74,5433
+monocle_apptrace/metamodel/spans/span_example.json,sha256=7ZAUssL1UYXlbKHre8PfeNlIhHnM28e2CH9EyHDTOt8,4402
+monocle_apptrace/metamodel/spans/span_format.json,sha256=GhfioGgMhG7St0DeYA1fgNtMkbr9wiQ1L2hovekRQ24,1512
+monocle_apptrace/metamodel/spans/span_types.json,sha256=jwVyPbYMhEf2Ea6Egmb3m1Za28ap9dgZIpJDhdE1BlY,361
+monocle_apptrace-0.2.0.dist-info/METADATA,sha256=zaIOrJwa-RLX1bWeBEfTCfeBGC2cuNeXKwPHAYYNRT8,5364
+monocle_apptrace-0.2.0.dist-info/WHEEL,sha256=1yFddiXMmvYK7QYTqtRNtX66WJ0Mz8PYEiEUoOUUxRY,87
+monocle_apptrace-0.2.0.dist-info/licenses/LICENSE,sha256=ay9trLiP5I7ZsFXo6AqtkLYdRqe5S9r-DrPOvsNlZrg,9136
+monocle_apptrace-0.2.0.dist-info/licenses/NOTICE,sha256=9jn4xtwM_uUetJMx5WqGnhrR7MIhpoRlpokjSTlyt8c,112
+monocle_apptrace-0.2.0.dist-info/RECORD,,