monocle-apptrace 0.3.0b2__tar.gz → 0.3.0b4__tar.gz

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

@@ -1,4 +1,4 @@
-## Version 0.3.0b2 (2024-12-10)
+## Version 0.3.0b4 (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))  

{monocle_apptrace-0.3.0b2 → monocle_apptrace-0.3.0b4}/Monocle_committer_guide.md

@@ -22,5 +22,35 @@ After setup of credentials, follow the commands below to publish the package to
 
 ```
 > python3 -m pip install pipenv
-> pipenv install monocle-observability
+> pipenv install monocle-apptrace
 ```
+### Running the testcases
+
+ 
+##### Activate the virtual environment
+```
+cd monocle
+monocle% python -m pip install pipenv
+monocle% pipenv --python 3.11.9
+monocle% source $(pipenv --venv)/bin/activate
+
+ ```
+##### Install the dependencies
+```
+monocle% pip install -e '.[dev]'
+ ```
+
+##### Run the unit tests
+```
+monocle% pytest tests/unit/*_test.py
+ ```
+ 
+##### Run the integration tests
+```
+monocle% pytest -m integration
+ ```
+
+###### Run the integration test individually
+```
+monocle% pytest tests/integration/test_langchain_rag_l_to_m.py
+```

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: monocle_apptrace
-Version: 0.3.0b2
+Version: 0.3.0b4
 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.0b2 → monocle_apptrace-0.3.0b4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "monocle_apptrace"
-version = "0.3.0b2"
+version = "0.3.0b4"
 authors = []
 description = "package with monocle genAI tracing"
 readme = "README.md"
@@ -23,8 +23,20 @@ dependencies = [
 ]
 
 [tool.pytest.ini_options]
+#log_cli = true
+#log_cli_level = "INFO"
+# Enable file logging
+log_file = "traces.log"
+log_file_level = "INFO"
+log_format = "%(asctime)s %(levelname)s %(pathname)s:%(lineno)d %(message)s"
+log_date_format = "%Y-%m-%d %H:%M:%S"
+
 pythonpath = [
-  "src"
+  "src",
+  "tests"
+]
+markers = [
+  "integration"
 ]
 
 [project.optional-dependencies]
@@ -46,7 +58,20 @@ dev = [
   'parameterized==0.9.0',
   'llama-index-llms-mistralai==0.1.20',
   'langchain-mistralai==0.1.13',
-  'mistral-haystack==0.0.2'
+  'mistral-haystack==0.0.2',
+  'langchain-aws==0.1.10',
+  'azure-storage-blob==12.22.0', # this is for blob exporter
+  'boto3==1.34.131', # this is for aws exporter
+  'llama-index-vector-stores-opensearch==0.1.10',
+  'haystack-ai==2.3.0',
+  'llama-index-llms-azure-openai==0.1.9',
+  'requests-aws4auth==1.2.3',
+  'opensearch-haystack==1.2.0',
+  'langchainhub==0.1.21',
+  'chromadb==0.4.22',
+  'flask',
+  'opentelemetry-instrumentation-flask',
+  'opendal==0.45.14'
 ]
 
 azure = [

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

@@ -25,17 +25,25 @@ class S3SpanExporter(SpanExporterBase):
         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_TIME_FORMAT = "%Y-%m-%d__%H.%M.%S"
         self.max_batch_size = 500
         self.export_interval = 1
-        self.s3_client = boto3.client(
-            's3',
-            aws_access_key_id=os.getenv('AWS_ACCESS_KEY_ID'),
-            aws_secret_access_key=os.getenv('AWS_SECRET_ACCESS_KEY'),
-            region_name=region_name,
-        )
+        if(os.getenv('MONOCLE_AWS_ACCESS_KEY_ID') and os.getenv('MONOCLE_AWS_SECRET_ACCESS_KEY')):
+            self.s3_client = boto3.client(
+                's3',
+                aws_access_key_id=os.getenv('MONOCLE_AWS_ACCESS_KEY_ID'),
+                aws_secret_access_key=os.getenv('MONOCLE_AWS_SECRET_ACCESS_KEY'),
+                region_name=region_name,
+            )
+        else:
+            self.s3_client = boto3.client(
+                's3',
+                aws_access_key_id=os.getenv('AWS_ACCESS_KEY_ID'),
+                aws_secret_access_key=os.getenv('AWS_SECRET_ACCESS_KEY'),
+                region_name=region_name,
+            )
         self.bucket_name = bucket_name or os.getenv('MONOCLE_S3_BUCKET_NAME','default-bucket')
-        self.file_prefix = DEFAULT_FILE_PREFIX
+        self.file_prefix = os.getenv('MONOCLE_S3_KEY_PREFIX', DEFAULT_FILE_PREFIX)
         self.time_format = DEFAULT_TIME_FORMAT
         self.export_queue = []
         self.last_export_time = time.time()
@@ -142,7 +150,8 @@ class S3SpanExporter(SpanExporterBase):
     @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"
+        prefix = self.file_prefix + os.environ.get('MONOCLE_S3_KEY_PREFIX_CURRENT', '')
+        file_name = f"{prefix}{current_time}.ndjson"
         self.s3_client.put_object(
             Bucket=self.bucket_name,
             Key=file_name,

monocle_apptrace-0.3.0b4/src/monocle_apptrace/exporters/aws/s3_exporter_opendal.py

@@ -0,0 +1,126 @@
+import os
+import time
+import datetime
+import logging
+import asyncio
+from typing import Sequence
+from opentelemetry.sdk.trace import ReadableSpan
+from opentelemetry.sdk.trace.export import SpanExportResult
+from monocle_apptrace.exporters.base_exporter import SpanExporterBase
+from opendal import Operator
+from opendal.exceptions import PermissionDenied, ConfigInvalid, Unexpected
+
+
+import json
+
+logger = logging.getLogger(__name__)
+class OpenDALS3Exporter(SpanExporterBase):
+    def __init__(self, bucket_name=None, region_name=None):
+        super().__init__()
+        DEFAULT_FILE_PREFIX = "monocle_trace_"
+        DEFAULT_TIME_FORMAT = "%Y-%m-%d__%H.%M.%S"
+        self.max_batch_size = 500
+        self.export_interval = 1
+        self.file_prefix = DEFAULT_FILE_PREFIX
+        self.time_format = DEFAULT_TIME_FORMAT
+        self.export_queue = []
+        self.last_export_time = time.time()
+        self.bucket_name = bucket_name or os.getenv("MONOCLE_S3_BUCKET_NAME", "default-bucket")
+
+        # Initialize OpenDAL S3 operator
+        self.op = Operator(
+            "s3",
+            root = "/",
+            region=os.getenv("AWS_REGION", region_name),
+            bucket=self.bucket_name,
+            access_key_id=os.getenv("AWS_ACCESS_KEY_ID"),
+            secret_access_key=os.getenv("AWS_SECRET_ACCESS_KEY"),
+        )
+
+
+    def export(self, spans: Sequence[ReadableSpan]) -> SpanExportResult:
+        """Synchronous export method that internally handles async logic."""
+        try:
+            # Run the asynchronous export logic in an event loop
+            asyncio.run(self.__export_async(spans))
+            return SpanExportResult.SUCCESS
+        except Exception as e:
+            logger.error(f"Error exporting spans: {e}")
+            return SpanExportResult.FAILURE
+
+    async def __export_async(self, spans: Sequence[ReadableSpan]) -> SpanExportResult:
+        try:
+            # Add spans to the export queue
+            for span in spans:
+                self.export_queue.append(span)
+                if len(self.export_queue) >= self.max_batch_size:
+                    await self.__export_spans()
+
+            # Check if it's time to force a flush
+            current_time = time.time()
+            if current_time - self.last_export_time >= self.export_interval:
+                await self.__export_spans()
+                self.last_export_time = current_time
+
+            return SpanExportResult.SUCCESS
+        except Exception as e:
+            logger.error(f"Error exporting spans: {e}")
+            return SpanExportResult.FAILURE
+
+    def __serialize_spans(self, spans: Sequence[ReadableSpan]) -> str:
+        try:
+            # Serialize spans to JSON or any other format you prefer
+            valid_json_list = []
+            for span in spans:
+                try:
+                    valid_json_list.append(span.to_json(indent=0).replace("\n", ""))
+                except json.JSONDecodeError as e:
+                    logger.warning(f"Invalid JSON format in span data: {span.context.span_id}. Error: {e}")
+                    continue
+            return "\n".join(valid_json_list) + "\n"
+        except Exception as e:
+            logger.warning(f"Error serializing spans: {e}")
+
+    async def __export_spans(self):
+        if not self.export_queue:
+            return
+        # Take a batch of spans from the queue
+        batch_to_export = self.export_queue[:self.max_batch_size]
+        serialized_data = self.__serialize_spans(batch_to_export)
+        self.export_queue = self.export_queue[self.max_batch_size:]
+        try:
+            self.__upload_to_s3(serialized_data)
+        except Exception as e:
+            logger.error(f"Failed to upload span batch: {e}")
+
+    @SpanExporterBase.retry_with_backoff(exceptions=(Unexpected))
+    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"
+        try:
+            # Attempt to write the span data batch to S3
+            self.op.write(file_name, span_data_batch.encode("utf-8"))
+            logger.info(f"Span batch uploaded to S3 as {file_name}.")
+
+        except PermissionDenied as e:
+            # S3 bucket is forbidden.
+            logger.error(f"Access to bucket {self.bucket_name} is forbidden (403).")
+            raise PermissionError(f"Access to bucket {self.bucket_name} is forbidden.")
+
+        except ConfigInvalid as e:
+            # Bucket does not exist.
+            if "404" in str(e):
+                logger.error("Bucket does not exist. Please check the bucket name and region.")
+                raise Exception(f"Bucket does not exist. Error: {e}")
+            else:
+                logger.error(f"Unexpected error when accessing bucket {self.bucket_name}: {e}")
+                raise e
+
+
+    async def force_flush(self, timeout_millis: int = 30000) -> bool:
+        await self.__export_spans()
+        return True
+
+    def shutdown(self) -> None:
+        logger.info("S3SpanExporter has been shut down.")

monocle_apptrace-0.3.0b4/src/monocle_apptrace/exporters/azure/blob_exporter_opendal.py

@@ -0,0 +1,147 @@
+import os
+import time
+import datetime
+import logging
+import asyncio
+from opentelemetry.sdk.trace import ReadableSpan
+from opentelemetry.sdk.trace.export import SpanExportResult
+from typing import Sequence
+from opendal import Operator
+from monocle_apptrace.exporters.base_exporter import SpanExporterBase
+from opendal.exceptions import Unexpected, PermissionDenied, NotFound
+import json
+
+logger = logging.getLogger(__name__)
+
+class OpenDALAzureExporter(SpanExporterBase):
+    def __init__(self, connection_string=None, container_name=None):
+        super().__init__()
+        DEFAULT_FILE_PREFIX = "monocle_trace_"
+        DEFAULT_TIME_FORMAT = "%Y-%m-%d_%H.%M.%S"
+        self.max_batch_size = 500
+        self.export_interval = 1
+        self.container_name = container_name
+
+        # Default values
+        self.file_prefix = DEFAULT_FILE_PREFIX
+        self.time_format = DEFAULT_TIME_FORMAT
+
+        # Validate input
+        if not connection_string:
+            connection_string = os.getenv('MONOCLE_BLOB_CONNECTION_STRING')
+            if not connection_string:
+                raise ValueError("Azure Storage connection string is not provided or set in environment variables.")
+
+        if not container_name:
+            container_name = os.getenv('MONOCLE_BLOB_CONTAINER_NAME', 'default-container')
+        endpoint, account_name , account_key = self.parse_connection_string(connection_string)
+
+        if not account_name or not account_key:
+            raise ValueError("AccountName or AccountKey missing in the connection string.")
+
+        try:
+            # Initialize OpenDAL operator with explicit credentials
+            self.operator = Operator(
+                "azblob",
+                endpoint=endpoint,
+                account_name=account_name,
+                account_key=account_key,
+                container=container_name
+            )
+        except Exception as e:
+            raise RuntimeError(f"Failed to initialize OpenDAL operator: {e}")
+
+
+    def parse_connection_string(self,connection_string):
+        connection_params = dict(item.split('=', 1) for item in connection_string.split(';') if '=' in item)
+
+        account_name = connection_params.get('AccountName')
+        account_key = connection_params.get('AccountKey')
+        endpoint_suffix = connection_params.get('EndpointSuffix')
+
+        if not all([account_name, account_key, endpoint_suffix]):
+            raise ValueError("Invalid connection string. Ensure it contains AccountName, AccountKey, and EndpointSuffix.")
+
+        endpoint = f"https://{account_name}.blob.{endpoint_suffix}"
+        return endpoint, account_name, account_key
+
+
+    def export(self, spans: Sequence[ReadableSpan]) -> SpanExportResult:
+        """Synchronous export method that internally handles async logic."""
+        try:
+            # Run the asynchronous export logic in an event loop
+            asyncio.run(self._export_async(spans))
+            return SpanExportResult.SUCCESS
+        except Exception as e:
+            logger.error(f"Error exporting spans: {e}")
+            return SpanExportResult.FAILURE
+
+    async def _export_async(self, spans: Sequence[ReadableSpan]):
+        """The actual async export logic is run here."""
+        # Add spans to the export queue
+        for span in spans:
+            self.export_queue.append(span)
+            if len(self.export_queue) >= self.max_batch_size:
+                await self.__export_spans()
+
+        # Force a flush if the interval has passed
+        current_time = time.time()
+        if current_time - self.last_export_time >= self.export_interval:
+            await self.__export_spans()
+            self.last_export_time = current_time
+
+    def __serialize_spans(self, spans: Sequence[ReadableSpan]) -> str:
+        try:
+            valid_json_list = []
+            for span in spans:
+                try:
+                    valid_json_list.append(span.to_json(indent=0).replace("\n", ""))
+                except json.JSONDecodeError as e:
+                    logger.warning(f"Invalid JSON format in span data: {span.context.span_id}. Error: {e}")
+                    continue
+
+            ndjson_data = "\n".join(valid_json_list) + "\n"
+            return ndjson_data
+        except Exception as e:
+            logger.warning(f"Error serializing spans: {e}")
+
+    async def __export_spans(self):
+        if len(self.export_queue) == 0:
+            return
+
+        batch_to_export = self.export_queue[:self.max_batch_size]
+        serialized_data = self.__serialize_spans(batch_to_export)
+        self.export_queue = self.export_queue[self.max_batch_size:]
+        try:
+            self.__upload_to_opendal(serialized_data)
+        except Exception as e:
+            logger.error(f"Failed to upload span batch: {e}")
+
+    @SpanExporterBase.retry_with_backoff(exceptions=(Unexpected,))
+    def __upload_to_opendal(self, span_data_batch: str):
+        current_time = datetime.datetime.now().strftime(self.time_format)
+        file_name = f"{self.file_prefix}{current_time}.ndjson"
+
+        try:
+            self.operator.write(file_name, span_data_batch.encode('utf-8'))
+            logger.info(f"Span batch uploaded to Azure Blob Storage as {file_name}.")
+        except PermissionDenied as e:
+            # Azure Container is forbidden.
+            logger.error(f"Access to container {self.container_name} is forbidden (403).")
+            raise PermissionError(f"Access to container {self.container_name} is forbidden.")
+
+        except NotFound as e:
+            # Container does not exist.
+            if "404" in str(e):
+                logger.error("Container does not exist. Please check the container name.")
+                raise Exception(f"Container does not exist. Error: {e}")
+            else:
+                logger.error(f"Unexpected NotFound error when accessing container {self.container_name}: {e}")
+                raise e
+
+    async def force_flush(self, timeout_millis: int = 30000) -> bool:
+        await self.__export_spans()
+        return True
+
+    def shutdown(self) -> None:
+        logger.info("OpenDALAzureExporter has been shut down.")

monocle_apptrace-0.3.0b4/src/monocle_apptrace/exporters/monocle_exporters.py

@@ -0,0 +1,45 @@
+from typing import Dict, Any, List
+import os
+import warnings
+from importlib import import_module
+from opentelemetry.sdk.trace.export import SpanExporter, ConsoleSpanExporter
+from monocle_apptrace.exporters.file_exporter import FileSpanExporter
+
+monocle_exporters: Dict[str, Any] = {
+    "s3": {"module": "monocle_apptrace.exporters.aws.s3_exporter", "class": "S3SpanExporter"},
+    "blob": {"module": "monocle_apptrace.exporters.azure.blob_exporter", "class": "AzureBlobSpanExporter"},
+    "okahu": {"module": "monocle_apptrace.exporters.okahu.okahu_exporter", "class": "OkahuSpanExporter"},
+    "file": {"module": "monocle_apptrace.exporters.file_exporter", "class": "FileSpanExporter"},
+    "memory": {"module": "opentelemetry.sdk.trace.export.in_memory_span_exporter", "class": "InMemorySpanExporter"},
+    "console": {"module": "opentelemetry.sdk.trace.export", "class": "ConsoleSpanExporter"}
+}
+
+
+def get_monocle_exporter() -> List[SpanExporter]:
+    # Retrieve the MONOCLE_EXPORTER environment variable and split it into a list
+    exporter_names = os.environ.get("MONOCLE_EXPORTER", "file").split(",")
+    exporters = []
+
+    for exporter_name in exporter_names:
+        exporter_name = exporter_name.strip()
+        try:
+            exporter_class_path = monocle_exporters[exporter_name]
+        except KeyError:
+            warnings.warn(f"Unsupported Monocle span exporter '{exporter_name}', skipping.")
+            continue
+        try:
+            exporter_module = import_module(exporter_class_path["module"])
+            exporter_class = getattr(exporter_module, exporter_class_path["class"])
+            exporters.append(exporter_class())
+        except Exception as ex:
+            warnings.warn(
+                f"Unable to initialize Monocle span exporter '{exporter_name}', error: {ex}. Using ConsoleSpanExporter as a fallback.")
+            exporters.append(ConsoleSpanExporter())
+            continue
+
+    # If no exporters were created, default to FileSpanExporter
+    if not exporters:
+        warnings.warn("No valid Monocle span exporters configured. Defaulting to FileSpanExporter.")
+        exporters.append(FileSpanExporter())
+
+    return exporters

{monocle_apptrace-0.3.0b2/src/monocle_apptrace → monocle_apptrace-0.3.0b4/src/monocle_apptrace/instrumentation/common}/constants.py

@@ -9,6 +9,8 @@ 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"
@@ -34,3 +36,14 @@ service_name_map = {
     AWS_LAMBDA_SERVICE_NAME: AWS_LAMBDA_FUNCTION_IDENTIFIER_ENV_NAME,
     GITHUB_CODESPACE_SERVICE_NAME: GITHUB_CODESPACE_IDENTIFIER_ENV_NAME
 }
+
+WORKFLOW_TYPE_KEY = "workflow_type"
+DATA_INPUT_KEY = "data.input"
+DATA_OUTPUT_KEY = "data.output"
+PROMPT_INPUT_KEY = "data.input"
+PROMPT_OUTPUT_KEY = "data.output"
+QUERY = "input"
+RESPONSE = "response"
+SESSION_PROPERTIES_KEY = "session"
+INFRA_SERVICE_KEY = "infra_service_name"
+META_DATA = 'metadata'