monocle-apptrace 0.2.0__py3-none-any.whl → 0.3.0b2__py3-none-any.whl

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/constants.py

@@ -3,20 +3,34 @@ 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"
 
-azure_service_map = {
+# 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
+    AZURE_FUNCTION_WORKER_ENV_NAME: AZURE_FUNCTION_NAME,
+    AWS_LAMBDA_ENV_NAME: AWS_LAMBDA_SERVICE_NAME,
+    GITHUB_CODESPACE_ENV_NAME: GITHUB_CODESPACE_SERVICE_NAME
 }
 
-aws_service_map = {
-    AWS_LAMBDA_ENV_NAME: AWS_LAMBDA_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/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/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/exporters/base_exporter.py

@@ -2,7 +2,6 @@ import time
 import random
 import logging
 from abc import ABC, abstractmethod
-from azure.core.exceptions import ServiceRequestError, ClientAuthenticationError
 from opentelemetry.sdk.trace import ReadableSpan
 from opentelemetry.sdk.trace.export import SpanExporter, SpanExportResult
 from typing import Sequence
@@ -28,20 +27,22 @@ class SpanExporterBase(ABC):
     def shutdown(self) -> None:
         pass
 
-    async def _retry_with_backoff(self, func, *args, **kwargs):
-        """Handle retries with exponential backoff."""
-        attempt = 0
-        while attempt < self.max_retries:
-            try:
-                return func(*args, **kwargs)
-            except ServiceRequestError as e:
-                logger.warning(f"Network connectivity error: {e}. Retrying in {self.backoff_factor ** attempt} seconds...")
-                sleep_time = self.backoff_factor * (2 ** attempt) + random.uniform(0, 1)
-                await asyncio.sleep(sleep_time)
-                attempt += 1
-            except ClientAuthenticationError as e:
-                logger.error(f"Failed to authenticate: {str(e)}")
-                break
-
-        logger.error("Max retries exceeded.")
-        raise ServiceRequestError(message="Max retries exceeded.")
+    @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/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/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/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/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/metamodel/maps/attributes/inference/langchain_entities.json

@@ -5,31 +5,53 @@
       {
         "_comment": "provider type ,name , deployment , inference_endpoint",
         "attribute": "type",
-        "accessor": "lambda instance,args:'inference.azure_oai'"
+        "accessor": "lambda arguments:'inference.azure_oai'"
       },
       {
         "attribute": "provider_name",
-        "accessor": "lambda instance,args:args['provider_name']"
+        "accessor": "lambda arguments:arguments['kwargs']['provider_name']"
       },
       {
         "attribute": "deployment",
-        "accessor": "lambda instance,args: resolve_from_alias(instance.__dict__, ['engine', 'azure_deployment', 'deployment_name', 'deployment_id', 'deployment'])"
+        "accessor": "lambda arguments: resolve_from_alias(arguments['instance'].__dict__, ['engine', 'azure_deployment', 'deployment_name', 'deployment_id', 'deployment'])"
       },
       {
         "attribute": "inference_endpoint",
-        "accessor": "lambda instance,args: resolve_from_alias(instance.__dict__, ['azure_endpoint', 'api_base']) or args['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 instance,args: resolve_from_alias(instance.__dict__, ['model', 'model_name'])"
+        "accessor": "lambda arguments: resolve_from_alias(arguments['instance'].__dict__, ['model', 'model_name']) or arguments['instance'].model_id"
       },
       {
         "attribute": "type",
-        "accessor": "lambda instance,args: 'model.llm.'+resolve_from_alias(instance.__dict__, ['model', 'model_name'])"
+        "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/metamodel/maps/attributes/inference/llamaindex_entities.json

@@ -5,31 +5,53 @@
       {
         "_comment": "provider type ,name , deployment , inference_endpoint",
         "attribute": "type",
-        "accessor": "lambda instance,args:'inference.azure_oai'"
+        "accessor": "lambda arguments:'inference.azure_oai'"
       },
       {
         "attribute": "provider_name",
-        "accessor": "lambda instance,args:args['provider_name']"
+        "accessor": "lambda arguments:arguments['kwargs']['provider_name']"
       },
       {
         "attribute": "deployment",
-        "accessor": "lambda instance,args: resolve_from_alias(instance.__dict__, ['engine', 'azure_deployment', 'deployment_name', 'deployment_id', 'deployment'])"
+        "accessor": "lambda arguments: resolve_from_alias(arguments['instance'].__dict__, ['engine', 'azure_deployment', 'deployment_name', 'deployment_id', 'deployment'])"
       },
       {
         "attribute": "inference_endpoint",
-        "accessor": "lambda instance,args: resolve_from_alias(instance.__dict__, ['azure_endpoint', 'api_base'])"
+        "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 instance,args: resolve_from_alias(instance.__dict__, ['model', 'model_name'])"
+        "accessor": "lambda arguments: resolve_from_alias(arguments['instance'].__dict__, ['model', 'model_name'])"
       },
       {
         "attribute": "type",
-        "accessor": "lambda instance,args: 'model.llm.'+resolve_from_alias(instance.__dict__, ['model', 'model_name'])"
+        "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/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/metamodel/maps/attributes/retrieval/langchain_entities.json

@@ -5,22 +5,26 @@
       {
         "_comment": "vector store name and type",
         "attribute": "name",
-        "accessor": "lambda instance,args: type(instance.vectorstore).__name__"
+        "accessor": "lambda arguments: type(arguments['instance'].vectorstore).__name__"
       },
       {
         "attribute": "type",
-        "accessor": "lambda instance,args: 'vectorstore.'+type(instance.vectorstore).__name__"
+        "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 instance,args: instance.vectorstore.embeddings.model"
+        "accessor": "lambda arguments: arguments['instance'].vectorstore.embeddings.model"
       },
       {
         "attribute": "type",
-        "accessor": "lambda instance ,args: 'model.embedding.'+instance.vectorstore.embeddings.model"
+        "accessor": "lambda arguments: 'model.embedding.'+arguments['instance'].vectorstore.embeddings.model"
       }
     ]
   ]

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

@@ -5,22 +5,26 @@
       {
         "_comment": "vector store name and type",
         "attribute": "name",
-        "accessor": "lambda instance,args: type(instance._vector_store).__name__"
+        "accessor": "lambda arguments: type(arguments['instance']._vector_store).__name__"
       },
       {
         "attribute": "type",
-        "accessor": "lambda instance,args: 'vectorstore.'+type(instance._vector_store).__name__"
+        "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 instance,args: instance._embed_model.model_name"
+        "accessor": "lambda arguments: arguments['instance']._embed_model.model_name"
       },
       {
         "attribute": "type",
-        "accessor": "lambda instance ,args: 'model.embedding.'+instance._embed_model.model_name"
+        "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"
     }
 ] 
 }