monocle-apptrace 0.2.0__tar.gz → 0.3.0b2__tar.gz

{monocle_apptrace-0.2.0 → monocle_apptrace-0.3.0b2}/.gitignore

@@ -12,4 +12,5 @@ traces.txt
 dist
 .tox
 .DS_Store
-Pipfile**
+Pipfile**
+launch.json

{monocle_apptrace-0.2.0 → monocle_apptrace-0.3.0b2}/CHANGELOG.md

@@ -1,3 +1,17 @@
+## Version 0.3.0b2 (2024-12-10)
+
+- Add dev dependency for Mistral AI integration ([#81](https://github.com/monocle2ai/monocle/pull/81))
+- Add VectorStore deployment URL capture support ([#80](https://github.com/monocle2ai/monocle/pull/80))  
+- Clean up cloud exporter implementation ([#79](https://github.com/monocle2ai/monocle/pull/79))
+- Capture inference span input/output events attributes ([#77](https://github.com/monocle2ai/monocle/pull/77))
+- Add release automation workflows ([#76](https://github.com/monocle2ai/monocle/pull/76))
+- Fix gaps in Monocle SDK implementation ([#72](https://github.com/monocle2ai/monocle/pull/72))  
+- Add kwargs and return value handling in Accessor ([#71](https://github.com/monocle2ai/monocle/pull/71))
+- Update workflow name formatting ([#69](https://github.com/monocle2ai/monocle/pull/69))
+- Implement Haystack metamodel support ([#68](https://github.com/monocle2ai/monocle/pull/68))
+
+## Version 0.2.0 (2024-12-05)
+
 ## 0.2.0 (Oct 22, 2024)
 
 - Ndjson format for S3 and Blob exporters ([#61](https://github.com/monocle2ai/monocle/pull/61))

{monocle_apptrace-0.2.0 → monocle_apptrace-0.3.0b2}/Monocle_User_Guide.md

@@ -40,6 +40,15 @@ You need to import monocle package and invoke the API ``setup_monocle_telemetry(
 
 ### Using Monocle's out of box support of genAI technology components
 Monocle community has done the hard work of figuring out what to trace and how to extract relevant details from multiple genAI technology components. For example, if you have a python app coded using LlamaIndex and using models hostsed in OpenAI, Monocle can seamlessly trace your app. All you need to do enable Monocle tracing.
+
+### Using Monocle's Support for Adding Custom Attributes
+Monocle provides users with the ability to add custom attributes to various spans, such as inference and retrieval spans, by utilizing the output processor within its metamodel. This feature allows for dynamic attribute assignment through lambda functions, which operate on an arguments dictionary.
+The arguments dictionary contains key-value pairs that can be used to compute custom attributes. The dictionary includes the following components: 
+```python
+arguments = {"instance":instance, "args":args, "kwargs":kwargs, "output":return_value}
+```
+By leveraging this dictionary, users can define custom attributes for spans, enabling the integration of additional context and information into the tracing process. The lambda functions used in the attributes field can access and process these values to enrich the span with relevant custom data.
+
 #### Example - Enable Monocle tracing in your application
 ```python
 from monocle_apptrace.instrumentor import setup_monocle_telemetry

{monocle_apptrace-0.2.0 → monocle_apptrace-0.3.0b2}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.3
+Metadata-Version: 2.4
 Name: monocle_apptrace
-Version: 0.2.0
+Version: 0.3.0b2
 Summary: package with monocle genAI tracing
 Project-URL: Homepage, https://github.com/monocle2ai/monocle
 Project-URL: Issues, https://github.com/monocle2ai/monocle/issues
@@ -25,11 +25,14 @@ 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-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: llama-index-embeddings-huggingface==0.2.0; 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==0.10.30; extra == 'dev'
+Requires-Dist: mistral-haystack==0.0.2; 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'

{monocle_apptrace-0.2.0 → monocle_apptrace-0.3.0b2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "monocle_apptrace"
-version = "0.2.0"
+version = "0.3.0b2"
 authors = []
 description = "package with monocle genAI tracing"
 readme = "README.md"
@@ -43,7 +43,10 @@ dev = [
   'llama-index==0.10.30',
   'llama-index-embeddings-huggingface==0.2.0',
   'llama-index-vector-stores-chroma==0.1.9',
-  'parameterized==0.9.0'
+  'parameterized==0.9.0',
+  'llama-index-llms-mistralai==0.1.20',
+  'langchain-mistralai==0.1.13',
+  'mistral-haystack==0.0.2'
 ]
 
 azure = [

monocle_apptrace-0.3.0b2/src/monocle_apptrace/botocore/__init__.py

@@ -0,0 +1,9 @@
+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-0.3.0b2/src/monocle_apptrace/constants.py

@@ -0,0 +1,36 @@
+# Azure environment constants
+AZURE_ML_ENDPOINT_ENV_NAME = "AZUREML_ENTRY_SCRIPT"
+AZURE_FUNCTION_WORKER_ENV_NAME = "FUNCTIONS_WORKER_RUNTIME"
+AZURE_APP_SERVICE_ENV_NAME = "WEBSITE_SITE_NAME"
+AWS_LAMBDA_ENV_NAME = "AWS_LAMBDA_RUNTIME_API"
+GITHUB_CODESPACE_ENV_NAME = "CODESPACES"
+
+AWS_LAMBDA_FUNCTION_IDENTIFIER_ENV_NAME = "AWS_LAMBDA_FUNCTION_NAME"
+AZURE_FUNCTION_IDENTIFIER_ENV_NAME = "WEBSITE_SITE_NAME"
+AZURE_APP_SERVICE_IDENTIFIER_ENV_NAME = "WEBSITE_DEPLOYMENT_ID"
+GITHUB_CODESPACE_IDENTIFIER_ENV_NAME = "GITHUB_REPOSITORY"
+# Azure naming reference can be found here
+# https://learn.microsoft.com/en-us/azure/cloud-adoption-framework/ready/azure-best-practices/resource-abbreviations
+AZURE_FUNCTION_NAME = "azure.func"
+AZURE_APP_SERVICE_NAME = "azure.asp"
+AZURE_ML_SERVICE_NAME = "azure.mlw"
+AWS_LAMBDA_SERVICE_NAME = "aws.lambda"
+GITHUB_CODESPACE_SERVICE_NAME = "github_codespace"
+
+# Env variables to identify infra service type
+service_type_map = {
+    AZURE_ML_ENDPOINT_ENV_NAME: AZURE_ML_SERVICE_NAME,
+    AZURE_APP_SERVICE_ENV_NAME: AZURE_APP_SERVICE_NAME,
+    AZURE_FUNCTION_WORKER_ENV_NAME: AZURE_FUNCTION_NAME,
+    AWS_LAMBDA_ENV_NAME: AWS_LAMBDA_SERVICE_NAME,
+    GITHUB_CODESPACE_ENV_NAME: GITHUB_CODESPACE_SERVICE_NAME
+}
+
+# Env variables to identify infra service name
+service_name_map = {
+    AZURE_APP_SERVICE_NAME: AZURE_APP_SERVICE_IDENTIFIER_ENV_NAME,
+    AZURE_FUNCTION_NAME: AZURE_FUNCTION_IDENTIFIER_ENV_NAME,
+    AZURE_ML_SERVICE_NAME: AZURE_ML_ENDPOINT_ENV_NAME,
+    AWS_LAMBDA_SERVICE_NAME: AWS_LAMBDA_FUNCTION_IDENTIFIER_ENV_NAME,
+    GITHUB_CODESPACE_SERVICE_NAME: GITHUB_CODESPACE_IDENTIFIER_ENV_NAME
+}

{monocle_apptrace-0.2.0 → monocle_apptrace-0.3.0b2}/src/monocle_apptrace/exporters/aws/s3_exporter.py

@@ -6,6 +6,13 @@ import logging
 import asyncio
 import boto3
 from botocore.exceptions import ClientError
+from botocore.exceptions import (
+    BotoCoreError,
+    ConnectionClosedError,
+    ConnectTimeoutError,
+    EndpointConnectionError,
+    ReadTimeoutError,
+)
 from opentelemetry.sdk.trace import ReadableSpan
 from opentelemetry.sdk.trace.export import SpanExporter, SpanExportResult
 from monocle_apptrace.exporters.base_exporter import SpanExporterBase
@@ -14,11 +21,11 @@ import json
 logger = logging.getLogger(__name__)
 
 class S3SpanExporter(SpanExporterBase):
-    def __init__(self, bucket_name=None, region_name="us-east-1"):
+    def __init__(self, bucket_name=None, region_name=None):
         super().__init__()
         # Use environment variables if credentials are not provided
-        DEFAULT_FILE_PREFIX = "monocle_trace__"
-        DEFAULT_TIME_FORMAT = "%Y-%m-%d__%H.%M.%S"
+        DEFAULT_FILE_PREFIX = "monocle_trace_"
+        DEFAULT_TIME_FORMAT = "%Y-%m-%d_%H.%M.%S"
         self.max_batch_size = 500
         self.export_interval = 1
         self.s3_client = boto3.client(
@@ -36,13 +43,10 @@ class S3SpanExporter(SpanExporterBase):
         # Check if bucket exists or create it
         if not self.__bucket_exists(self.bucket_name):
             try:
-                if region_name == "us-east-1":
-                    self.s3_client.create_bucket(Bucket=self.bucket_name)
-                else:
-                    self.s3_client.create_bucket(
-                    Bucket=self.bucket_name,
-                    CreateBucketConfiguration={'LocationConstraint': region_name}
-                     )
+                self.s3_client.create_bucket(
+                Bucket=self.bucket_name,
+                CreateBucketConfiguration={'LocationConstraint': region_name}
+                 )
                 logger.info(f"Bucket {self.bucket_name} created successfully.")
             except ClientError as e:
                 logger.error(f"Error creating bucket {self.bucket_name}: {e}")
@@ -131,15 +135,11 @@ class S3SpanExporter(SpanExporterBase):
         serialized_data = self.__serialize_spans(batch_to_export)
         self.export_queue = self.export_queue[self.max_batch_size:]
         try:
-            if asyncio.get_event_loop().is_running():
-                task = asyncio.create_task(self._retry_with_backoff(self.__upload_to_s3, serialized_data))
-                await task
-            else:
-                await self._retry_with_backoff(self.__upload_to_s3, serialized_data)
-
+            self.__upload_to_s3(serialized_data)
         except Exception as e:
             logger.error(f"Failed to upload span batch: {e}")
 
+    @SpanExporterBase.retry_with_backoff(exceptions=(EndpointConnectionError, ConnectionClosedError, ReadTimeoutError, ConnectTimeoutError))
     def __upload_to_s3(self, span_data_batch: str):
         current_time = datetime.datetime.now().strftime(self.time_format)
         file_name = f"{self.file_prefix}{current_time}.ndjson"

{monocle_apptrace-0.2.0 → monocle_apptrace-0.3.0b2}/src/monocle_apptrace/exporters/azure/blob_exporter.py

@@ -105,14 +105,11 @@ class AzureBlobSpanExporter(SpanExporterBase):
         serialized_data = self.__serialize_spans(batch_to_export)
         self.export_queue = self.export_queue[self.max_batch_size:]
         try:
-            if asyncio.get_event_loop().is_running():
-                task = asyncio.create_task(self._retry_with_backoff(self.__upload_to_blob, serialized_data))
-                await task
-            else:
-                await self._retry_with_backoff(self.__upload_to_blob, serialized_data)
+            self.__upload_to_blob(serialized_data)
         except Exception as e:
             logger.error(f"Failed to upload span batch: {e}")
 
+    @SpanExporterBase.retry_with_backoff(exceptions=(ResourceNotFoundError, ClientAuthenticationError, ServiceRequestError))
     def __upload_to_blob(self, span_data_batch: str):
         current_time = datetime.datetime.now().strftime(self.time_format)
         file_name = f"{self.file_prefix}{current_time}.ndjson"

monocle_apptrace-0.3.0b2/src/monocle_apptrace/exporters/base_exporter.py

@@ -0,0 +1,48 @@
+import time
+import random
+import logging
+from abc import ABC, abstractmethod
+from opentelemetry.sdk.trace import ReadableSpan
+from opentelemetry.sdk.trace.export import SpanExporter, SpanExportResult
+from typing import Sequence
+import asyncio
+
+logger = logging.getLogger(__name__)
+
+class SpanExporterBase(ABC):
+    def __init__(self):
+        self.backoff_factor = 2
+        self.max_retries = 10
+        self.export_queue = []
+        self.last_export_time = time.time()
+
+    @abstractmethod
+    async def export(self, spans: Sequence[ReadableSpan]) -> SpanExportResult:
+        pass
+
+    @abstractmethod
+    async def force_flush(self, timeout_millis: int = 30000) -> bool:
+        pass
+
+    def shutdown(self) -> None:
+        pass
+
+    @staticmethod
+    def retry_with_backoff(retries=3, backoff_in_seconds=1, max_backoff_in_seconds=32, exceptions=(Exception,)):
+        def decorator(func):
+            def wrapper(*args, **kwargs):
+                attempt = 0
+                while attempt < retries:
+                    try:
+                        return func(*args, **kwargs)
+                    except exceptions as e:
+                        attempt += 1
+                        sleep_time = min(max_backoff_in_seconds, backoff_in_seconds * (2 ** (attempt - 1)))
+                        sleep_time = sleep_time * (1 + random.uniform(-0.1, 0.1))  # Add jitter
+                        logger.warning(f"Network connectivity error, Attempt {attempt} failed: {e}. Retrying in {sleep_time:.2f} seconds...")
+                        time.sleep(sleep_time)
+                raise Exception(f"Failed after {retries} attempts")
+
+            return wrapper
+
+        return decorator

{monocle_apptrace-0.2.0 → monocle_apptrace-0.3.0b2}/src/monocle_apptrace/instrumentor.py

@@ -33,8 +33,8 @@ class MonocleInstrumentor(BaseInstrumentor):
         return _instruments
 
     def _instrument(self, **kwargs):
-        tracer_provider = kwargs.get("tracer_provider")
-        tracer = get_tracer(instrumenting_module_name=__name__, tracer_provider=tracer_provider)
+        tracer_provider: TracerProvider = kwargs.get("tracer_provider")
+        tracer = get_tracer(instrumenting_module_name="monocle_apptrace", tracer_provider=tracer_provider)
 
         user_method_list = [
             {
@@ -107,7 +107,7 @@ def setup_monocle_telemetry(
     instrumentor = MonocleInstrumentor(user_wrapper_methods=wrapper_methods or [])
     # instrumentor.app_name = workflow_name
     if not instrumentor.is_instrumented_by_opentelemetry:
-        instrumentor.instrument()
+        instrumentor.instrument(trace_provider=trace_provider)
 
 def on_processor_start(span: Span, parent_context):
     context_properties = get_value(SESSION_PROPERTIES_KEY)

monocle_apptrace-0.3.0b2/src/monocle_apptrace/message_processing.py

@@ -0,0 +1,80 @@
+"""
+This module provides utility functions for extracting system, user,
+and assistant messages from various input formats.
+"""
+
+import logging
+from monocle_apptrace.utils import get_attribute
+DATA_INPUT_KEY = "data.input"
+
+logger = logging.getLogger(__name__)
+def extract_messages(args):
+    """Extract system and user messages"""
+    try:
+        messages = []
+        args_input = get_attribute(DATA_INPUT_KEY)
+        if args_input:
+            messages.append(args_input)
+            return messages
+        if args and isinstance(args, tuple) and len(args) > 0:
+            if hasattr(args[0], "messages") and isinstance(args[0].messages, list):
+                for msg in args[0].messages:
+                    if hasattr(msg, 'content') and hasattr(msg, 'type'):
+                        messages.append({msg.type: msg.content})
+            elif isinstance(args[0], list):  #llama
+                for msg in args[0]:
+                    if hasattr(msg, 'content') and hasattr(msg, 'role'):
+                        if hasattr(msg.role, 'value'):
+                            role = msg.role.value
+                        else:
+                            role = msg.role
+                        if msg.role == "system":
+                            messages.append({role: msg.content})
+                        elif msg.role in ["user", "human"]:
+                            user_message = extract_query_from_content(msg.content)
+                            messages.append({role: user_message})
+        return 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]
+        if "replies" in response:
+            reply = response["replies"][0]
+            if hasattr(reply, 'content'):
+                return [reply.content]
+            return [reply]
+        if isinstance(response, dict):
+            return [response]
+        return []
+    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 ""

monocle_apptrace-0.3.0b2/src/monocle_apptrace/metamodel/maps/attributes/inference/botocore_entities.json

@@ -0,0 +1,27 @@
+{
+  "type": "inference",
+  "attributes": [
+    [
+      {
+        "_comment": "provider type  , inference_endpoint",
+        "attribute": "type",
+        "accessor": "lambda arguments:'inference.aws_sagemaker'"
+      },
+      {
+        "attribute": "inference_endpoint",
+        "accessor": "lambda arguments: resolve_from_alias(arguments['instance'].__dict__, ['azure_endpoint', 'api_base']) or arguments['instance'].meta.endpoint_url"
+      }
+    ],
+    [
+      {
+        "_comment": "LLM Model",
+        "attribute": "name",
+        "accessor": "lambda arguments: resolve_from_alias(arguments['instance'].__dict__, ['model', 'model_name']) or arguments['kwargs'].get('EndpointName', '')"
+      },
+      {
+        "attribute": "type",
+        "accessor": "lambda arguments: 'model.llm.' + (resolve_from_alias(arguments['instance'].__dict__, ['model', 'model_name']) or arguments['kwargs'].get('EndpointName', ''))"
+      }
+    ]
+  ]
+}

monocle_apptrace-0.3.0b2/src/monocle_apptrace/metamodel/maps/attributes/inference/haystack_entities.json

@@ -0,0 +1,57 @@
+{
+  "type": "inference",
+  "attributes": [
+    [
+      {
+        "_comment": "provider type ,name , deployment , inference_endpoint",
+        "attribute": "type",
+        "accessor": "lambda arguments:'inference.azure_oai'"
+      },
+      {
+        "attribute": "provider_name",
+        "accessor": "lambda arguments:arguments['kwargs']['provider_name']"
+      },
+      {
+        "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 arguments['kwargs']['inference_endpoint']"
+      }
+    ],
+    [
+      {
+        "_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: extract_messages(arguments['args'])"
+        }
+      ]
+    },
+    {
+      "name":"data.output",
+      "attributes": [
+        {
+            "_comment": "this is response from LLM",
+            "attribute": "response",
+            "accessor": "lambda response: extract_assistant_message(response)"
+        }
+      ]
+   }
+  ]
+}

monocle_apptrace-0.3.0b2/src/monocle_apptrace/metamodel/maps/attributes/inference/langchain_entities.json

@@ -0,0 +1,57 @@
+{
+  "type": "inference",
+  "attributes": [
+    [
+      {
+        "_comment": "provider type ,name , deployment , inference_endpoint",
+        "attribute": "type",
+        "accessor": "lambda arguments:'inference.azure_oai'"
+      },
+      {
+        "attribute": "provider_name",
+        "accessor": "lambda arguments:arguments['kwargs']['provider_name']"
+      },
+      {
+        "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 arguments['kwargs']['inference_endpoint']"
+      }
+    ],
+    [
+      {
+        "_comment": "LLM Model",
+        "attribute": "name",
+        "accessor": "lambda arguments: resolve_from_alias(arguments['instance'].__dict__, ['model', 'model_name']) or arguments['instance'].model_id"
+      },
+      {
+        "attribute": "type",
+        "accessor": "lambda arguments: 'model.llm.'+ (resolve_from_alias(arguments['instance'].__dict__, ['model', 'model_name']) or arguments['instance'].model_id)"
+      }
+    ]
+  ],
+  "events": [
+    { "name":"data.input",
+      "attributes": [
+
+        {
+            "_comment": "this is instruction and user query to LLM",
+            "attribute": "input",
+            "accessor": "lambda arguments: extract_messages(arguments['args'])"
+        }
+      ]
+    },
+    {
+      "name":"data.output",
+      "attributes": [
+        {
+            "_comment": "this is response from LLM",
+            "attribute": "response",
+            "accessor": "lambda response: extract_assistant_message(response)"
+        }
+      ]
+   }
+  ]
+}

monocle_apptrace-0.3.0b2/src/monocle_apptrace/metamodel/maps/attributes/inference/llamaindex_entities.json

@@ -0,0 +1,57 @@
+{
+  "type": "inference",
+  "attributes": [
+    [
+      {
+        "_comment": "provider type ,name , deployment , inference_endpoint",
+        "attribute": "type",
+        "accessor": "lambda arguments:'inference.azure_oai'"
+      },
+      {
+        "attribute": "provider_name",
+        "accessor": "lambda arguments:arguments['kwargs']['provider_name']"
+      },
+      {
+        "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 arguments['kwargs']['inference_endpoint']"
+      }
+    ],
+    [
+      {
+        "_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: extract_messages(arguments['args'])"
+        }
+      ]
+    },
+    {
+      "name":"data.output",
+      "attributes": [
+        {
+            "_comment": "this is response from LLM",
+            "attribute": "response",
+            "accessor": "lambda response: extract_assistant_message(response)"
+        }
+      ]
+   }
+  ]
+}

monocle_apptrace-0.3.0b2/src/monocle_apptrace/metamodel/maps/attributes/retrieval/haystack_entities.json

@@ -0,0 +1,31 @@
+{
+  "type": "retrieval",
+  "attributes": [
+    [
+      {
+        "_comment": "vector store name and type",
+        "attribute": "name",
+         "accessor": "lambda arguments: resolve_from_alias(arguments['instance'].__dict__, ['document_store', '_document_store']).__class__.__name__"
+      },
+      {
+        "attribute": "type",
+        "accessor": "lambda arguments: 'vectorstore.'+resolve_from_alias(arguments['instance'].__dict__, ['document_store', '_document_store']).__class__.__name__"
+      },
+      {
+        "attribute": "deployment",
+        "accessor": "lambda arguments: get_vectorstore_deployment(resolve_from_alias(arguments['instance'].__dict__, ['document_store', '_document_store']).__dict__)"
+      }
+    ],
+    [
+      {
+        "_comment": "embedding model name and type",
+        "attribute": "name",
+        "accessor": "lambda arguments: get_embedding_model()"
+      },
+      {
+        "attribute": "type",
+        "accessor": "lambda arguments: 'model.embedding.'+get_embedding_model()"
+      }
+    ]
+  ]
+}

monocle_apptrace-0.3.0b2/src/monocle_apptrace/metamodel/maps/attributes/retrieval/langchain_entities.json

@@ -0,0 +1,31 @@
+{
+  "type": "retrieval",
+  "attributes": [
+    [
+      {
+        "_comment": "vector store name and type",
+        "attribute": "name",
+        "accessor": "lambda arguments: type(arguments['instance'].vectorstore).__name__"
+      },
+      {
+        "attribute": "type",
+        "accessor": "lambda arguments: 'vectorstore.'+type(arguments['instance'].vectorstore).__name__"
+      },
+      {
+        "attribute": "deployment",
+        "accessor": "lambda arguments: get_vectorstore_deployment(arguments['instance'].vectorstore.__dict__)"
+      }
+    ],
+    [
+      {
+        "_comment": "embedding model name and type",
+        "attribute": "name",
+        "accessor": "lambda arguments: arguments['instance'].vectorstore.embeddings.model"
+      },
+      {
+        "attribute": "type",
+        "accessor": "lambda arguments: 'model.embedding.'+arguments['instance'].vectorstore.embeddings.model"
+      }
+    ]
+  ]
+}