monocle-apptrace 0.6.0__tar.gz → 0.7.0__tar.gz

{monocle_apptrace-0.6.0 → monocle_apptrace-0.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: monocle_apptrace
-Version: 0.6.0
+Version: 0.7.0
 Summary: package with monocle genAI tracing
 Project-URL: Homepage, https://github.com/monocle2ai/monocle
 Project-URL: Issues, https://github.com/monocle2ai/monocle/issues
@@ -14,6 +14,7 @@ Requires-Dist: opentelemetry-api>=1.21.0
 Requires-Dist: opentelemetry-instrumentation
 Requires-Dist: opentelemetry-sdk>=1.21.0
 Requires-Dist: requests
+Requires-Dist: rfc3986>=2.0.0
 Requires-Dist: wrapt>=1.14.0
 Provides-Extra: ai-test
 Requires-Dist: bert-score; extra == 'ai-test'
@@ -21,20 +22,23 @@ Requires-Dist: transformers; extra == 'ai-test'
 Provides-Extra: aws
 Requires-Dist: boto3==1.37.24; extra == 'aws'
 Provides-Extra: azure
+Requires-Dist: azure-ai-inference; extra == 'azure'
 Requires-Dist: azure-storage-blob==12.22.0; extra == 'azure'
 Provides-Extra: dev
 Requires-Dist: a2a-sdk==0.3.6; extra == 'dev'
 Requires-Dist: anthropic-haystack; extra == 'dev'
 Requires-Dist: anthropic==0.57.1; extra == 'dev'
 Requires-Dist: azure-storage-blob==12.22.0; extra == 'dev'
-Requires-Dist: boto3==1.37.24; extra == 'dev'
+Requires-Dist: boto3==1.39.0; extra == 'dev'
 Requires-Dist: chromadb==1.0.15; extra == 'dev'
 Requires-Dist: click==8.2.1; extra == 'dev'
-Requires-Dist: datasets==2.20.0; extra == 'dev'
+Requires-Dist: crewai==0.95.0; extra == 'dev'
+Requires-Dist: datasets==4.3.0; extra == 'dev'
 Requires-Dist: faiss-cpu==1.8.0; extra == 'dev'
 Requires-Dist: fastapi>=0.115.0; extra == 'dev'
 Requires-Dist: flask; extra == 'dev'
 Requires-Dist: google-adk==1.10.0; extra == 'dev'
+Requires-Dist: google-ai-haystack; extra == 'dev'
 Requires-Dist: google-generativeai==0.8.5; extra == 'dev'
 Requires-Dist: haystack-ai==2.3.0; extra == 'dev'
 Requires-Dist: httpx==0.28.1; extra == 'dev'
@@ -52,6 +56,7 @@ Requires-Dist: langchain==0.3.25; extra == 'dev'
 Requires-Dist: langchainhub==0.1.21; extra == 'dev'
 Requires-Dist: langgraph-supervisor==0.0.28; extra == 'dev'
 Requires-Dist: langgraph==0.5.4; extra == 'dev'
+Requires-Dist: litellm==1.77.5; extra == 'dev'
 Requires-Dist: llama-index-embeddings-huggingface==0.6.0; extra == 'dev'
 Requires-Dist: llama-index-llms-anthropic==0.8.1; extra == 'dev'
 Requires-Dist: llama-index-llms-azure-openai==0.4.0; extra == 'dev'
@@ -72,12 +77,19 @@ Requires-Dist: opentelemetry-instrumentation-flask; extra == 'dev'
 Requires-Dist: parameterized==0.9.0; extra == 'dev'
 Requires-Dist: pydantic==2.11.7; extra == 'dev'
 Requires-Dist: pytest-asyncio==0.26.0; extra == 'dev'
+Requires-Dist: pytest-venv; extra == 'dev'
 Requires-Dist: pytest==8.3.5; extra == 'dev'
 Requires-Dist: python-dotenv>=1.1.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'
 Requires-Dist: uvicorn==0.35.0; extra == 'dev'
+Provides-Extra: dev-gemini
+Requires-Dist: llama-index-llms-gemini==0.6.0; extra == 'dev-gemini'
+Provides-Extra: dev-strands
+Requires-Dist: strands-agents-tools==0.2.10; extra == 'dev-strands'
+Requires-Dist: strands-agents==1.11.0; extra == 'dev-strands'
+Provides-Extra: dev-tranformers
+Requires-Dist: sentence-transformers==3.3.0; extra == 'dev-tranformers'
 Description-Content-Type: text/markdown
 
 # Monocle Apptrace

{monocle_apptrace-0.6.0 → monocle_apptrace-0.7.0}/pyproject.toml

@@ -10,7 +10,7 @@ commands = [
 
 [project]
 name = "monocle_apptrace"
-version = "0.6.0"
+version = "0.7.0"
 authors = [
   { name="Okahu Inc.", email="okahu-pypi@okahu.ai" },
 ]
@@ -26,17 +26,18 @@ classifiers = [
 dependencies = [
    'requests',
    'wrapt>=1.14.0',
+   'rfc3986>=2.0.0',
    'opentelemetry-api>=1.21.0',
    'opentelemetry-sdk>=1.21.0',
    'opentelemetry-instrumentation',
 ]
 
 [tool.pytest.ini_options]
-#log_cli = true
-#log_cli_level = "INFO"
+log_cli = true
+log_cli_level = "INFO"
 # Enable file logging
-log_file = "traces.log"
-log_file_level = "INFO"
+#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"
 
@@ -44,8 +45,27 @@ pythonpath = [
   "src",
   "tests"
 ]
-markers = [
-  "integration"
+
+# Simple ignore patterns - uncomment lines to ignore specific tests
+# Just uncomment the patterns you want to ignore:
+
+#ignore = [
+#  "tests/integration/",                    # Ignore ALL integration tests
+#  "tests/unit/",                          # Ignore ALL unit tests
+#]
+
+# Or ignore specific test files/patterns:
+#ignore = [
+#  "tests/integration/test_langchain_bedrock_sample.py",
+#  "tests/integration/test_anthropic_*.py",
+#  "tests/integration/test_azure_*.py", 
+#  "tests/integration/test_openai_*.py",
+#  "tests/unit/*_processor_test.py",
+#]
+
+# Test discovery patterns
+testpaths = [
+  "tests"
 ]
 
 [project.optional-dependencies]
@@ -59,13 +79,13 @@ dev = [
   'langchain-chroma==0.2.4',
   'langchain-community==0.3.24',
   'langchain==0.3.25',
-  'datasets==2.20.0',
+  'datasets==4.3.0',
   'numpy==1.26.4',
   'types-requests==2.31.0.20240106',
   'InstructorEmbedding==1.0.1',
-  'sentence-transformers==2.6.1',
   'faiss-cpu==1.8.0',
   'pytest==8.3.5',
+  'pytest-venv',
   'llama-index==0.13.0',
   'llama-index-llms-openai==0.5.0',
   'llama-index-tools-mcp==0.3.0',
@@ -77,7 +97,7 @@ dev = [
   'mistral-haystack==0.0.2',
   'langchain-aws==0.2.23',
   'azure-storage-blob==12.22.0', # this is for blob exporter
-  'boto3==1.37.24', # this is for aws exporter
+  'boto3==1.39.0', # this is for aws exporter
   'llama-index-vector-stores-opensearch==0.6.0',
   'haystack-ai==2.3.0',
   'llama-index-llms-azure-openai==0.4.0',
@@ -109,11 +129,28 @@ dev = [
   'google-generativeai==0.8.5',
   'openai-agents==0.2.6',
   'mistralai==1.9.9',
-  'huggingface_hub==0.35.3'
+  'huggingface_hub==0.35.3',
+  'litellm==1.77.5',
+  'google-ai-haystack',
+  'crewai==0.95.0'
+]
+
+dev_tranformers = [
+    'sentence-transformers==3.3.0'
+]
+
+dev_gemini = [
+  'llama-index-llms-gemini==0.6.0'
+]
+
+dev_strands = [
+  'strands-agents==1.11.0',
+  'strands-agents-tools==0.2.10'
 ]
 
 azure = [
     'azure-storage-blob==12.22.0',
+    'azure-ai-inference'
 ]
 
 aws = [

{monocle_apptrace-0.6.0 → monocle_apptrace-0.7.0}/src/monocle_apptrace/exporters/aws/s3_exporter.py

@@ -1,6 +1,4 @@
 import os
-import time
-import random
 import datetime
 import logging
 import asyncio
@@ -15,12 +13,14 @@ from botocore.exceptions import (
 )
 from opentelemetry.sdk.trace import ReadableSpan
 from opentelemetry.sdk.trace.export import SpanExporter, SpanExportResult
-from monocle_apptrace.exporters.base_exporter import SpanExporterBase
+from monocle_apptrace.exporters.base_exporter import SpanExporterBase, format_trace_id_without_0x
 from monocle_apptrace.exporters.exporter_processor import ExportTaskProcessor
-from typing import Sequence, Optional
+from typing import Sequence, Optional, Dict, List, Tuple
 import json
 logger = logging.getLogger(__name__)
 
+HANDLE_TIMEOUT_SECONDS = 60
+
 class S3SpanExporter(SpanExporterBase):
     def __init__(self, bucket_name=None, region_name=None, task_processor: Optional[ExportTaskProcessor] = None):
         super().__init__()
@@ -29,6 +29,8 @@ class S3SpanExporter(SpanExporterBase):
         DEFAULT_TIME_FORMAT = "%Y-%m-%d__%H.%M.%S"
         self.max_batch_size = 500
         self.export_interval = 1
+        # Dictionary to store spans by trace_id: {trace_id: (spans_list, creation_time, has_root_span)}
+        self.trace_spans: Dict[int, Tuple[List[ReadableSpan], datetime.datetime, bool]] = {}
         if(os.getenv('MONOCLE_AWS_ACCESS_KEY_ID') and os.getenv('MONOCLE_AWS_SECRET_ACCESS_KEY')):
             self.s3_client = boto3.client(
                 's3',
@@ -46,8 +48,6 @@ class S3SpanExporter(SpanExporterBase):
         self.bucket_name = bucket_name or os.getenv('MONOCLE_S3_BUCKET_NAME','default-bucket')
         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()
         self.task_processor = task_processor
         if self.task_processor is not None:
             self.task_processor.start()
@@ -92,6 +92,47 @@ class S3SpanExporter(SpanExporterBase):
             logger.error(f"Type error while checking bucket existence: {e}")
             raise e
 
+    def _cleanup_expired_traces(self) -> None:
+        """Upload and remove traces that have exceeded the timeout."""
+        current_time = datetime.datetime.now()
+        expired_trace_ids = []
+        
+        for trace_id, (spans, creation_time, _) in self.trace_spans.items():
+            if (current_time - creation_time).total_seconds() > HANDLE_TIMEOUT_SECONDS:
+                expired_trace_ids.append(trace_id)
+        
+        for trace_id in expired_trace_ids:
+            self._upload_trace(trace_id)
+
+    def _add_spans_to_trace(self, trace_id: int, spans: List[ReadableSpan], has_root: bool = False) -> None:
+        """Add spans to a trace buffer, creating it if needed."""
+        if trace_id in self.trace_spans:
+            existing_spans, creation_time, existing_root = self.trace_spans[trace_id]
+            existing_spans.extend(spans)
+            has_root = has_root or existing_root
+            self.trace_spans[trace_id] = (existing_spans, creation_time, has_root)
+        else:
+            self.trace_spans[trace_id] = (spans.copy(), datetime.datetime.now(), has_root)
+
+    def _upload_trace(self, trace_id: int) -> None:
+        """Upload a specific trace to S3 and remove it from the buffer."""
+        if trace_id not in self.trace_spans:
+            return
+        
+        spans, _, _ = self.trace_spans[trace_id]
+        if len(spans) == 0:
+            del self.trace_spans[trace_id]
+            return
+        
+        serialized_data = self.__serialize_spans(spans)
+        if serialized_data:
+            try:
+                self.__upload_to_s3_with_trace_id(serialized_data, trace_id)
+            except Exception as e:
+                logger.error(f"Failed to upload trace {format_trace_id_without_0x(trace_id)}: {e}")
+        
+        del self.trace_spans[trace_id]
+
     def export(self, spans: Sequence[ReadableSpan]) -> SpanExportResult:
         """Synchronous export method that internally handles async logic."""
         try:
@@ -106,18 +147,44 @@ class S3SpanExporter(SpanExporterBase):
     async def __export_async(self, spans: Sequence[ReadableSpan]) -> SpanExportResult:
         try:
             logger.info(f"__export_async {len(spans)} spans to S3.")
-            # Add spans to the export queue
+            
+            # Cleanup expired traces first
+            self._cleanup_expired_traces()
+            
+            # Group spans by trace_id
+            spans_by_trace = {}
+            root_span_traces = set()
+            
             for span in spans:
-                self.export_queue.append(span)
-                # If the queue reaches MAX_BATCH_SIZE, export the spans
-                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()  # Export spans if time interval has passed
-                self.last_export_time = current_time  # Reset the last export time
+                if self.skip_export(span):
+                    continue
+                
+                trace_id = span.context.trace_id
+                if trace_id not in spans_by_trace:
+                    spans_by_trace[trace_id] = []
+                spans_by_trace[trace_id].append(span)
+                
+                # Check if this span is a root span (no parent)
+                if not span.parent:
+                    root_span_traces.add(trace_id)
+            
+            # Add spans to their respective trace buffers
+            for trace_id, trace_spans in spans_by_trace.items():
+                has_root = trace_id in root_span_traces
+                self._add_spans_to_trace(trace_id, trace_spans, has_root)
+            
+            # Upload complete traces (those with root spans)
+            for trace_id in root_span_traces:
+                if self.task_processor is not None and callable(getattr(self.task_processor, 'queue_task', None)):
+                    # Queue the upload task
+                    if trace_id in self.trace_spans:
+                        spans_to_upload, _, _ = self.trace_spans[trace_id]
+                        serialized_data = self.__serialize_spans(spans_to_upload)
+                        if serialized_data:
+                            self.task_processor.queue_task(self.__upload_to_s3_with_trace_id, serialized_data, trace_id, True)
+                        del self.trace_spans[trace_id]
+                else:
+                    self._upload_trace(trace_id)
 
             return SpanExportResult.SUCCESS
         except Exception as e:
@@ -140,44 +207,35 @@ class S3SpanExporter(SpanExporterBase):
             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
-
-        # 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:]
-        # to calculate is_root_span loop over each span in batch_to_export and check if parent id is none or null
-        is_root_span = any(not span.parent for span in batch_to_export)
-        logger.info(f"Exporting {len(batch_to_export)} spans to S3 is_root_span : {is_root_span}.")
-        if self.task_processor is not None and callable(getattr(self.task_processor, 'queue_task', None)):
-            self.task_processor.queue_task(self.__upload_to_s3, serialized_data, is_root_span)
-        else:
-            try:
-                self.__upload_to_s3(serialized_data)
-            except Exception as e:
-                logger.error(f"Failed to upload span batch: {e}")
+            return ""
 
     @SpanExporterBase.retry_with_backoff(exceptions=(EndpointConnectionError, ConnectionClosedError, ReadTimeoutError, ConnectTimeoutError))
-    def __upload_to_s3(self, span_data_batch: str):
+    def __upload_to_s3_with_trace_id(self, span_data_batch: str, trace_id: int):
+        """Upload spans for a specific trace to S3 with trace ID in filename."""
         current_time = datetime.datetime.now().strftime(self.time_format)
         prefix = self.file_prefix + os.environ.get('MONOCLE_S3_KEY_PREFIX_CURRENT', '')
-        file_name = f"{prefix}{current_time}.ndjson"
+        file_name = f"{prefix}{current_time}_{format_trace_id_without_0x(trace_id)}.ndjson"
         self.s3_client.put_object(
             Bucket=self.bucket_name,
             Key=file_name,
             Body=span_data_batch
         )
-        logger.debug(f"Span batch uploaded to AWS S3 as {file_name}.")
+        logger.debug(f"Trace {format_trace_id_without_0x(trace_id)} uploaded to AWS S3 as {file_name}.")
 
     async def force_flush(self, timeout_millis: int = 30000) -> bool:
-        await self.__export_spans()  # Export any remaining spans in the queue
+        """Flush all pending traces to S3."""
+        trace_ids_to_upload = list(self.trace_spans.keys())
+        for trace_id in trace_ids_to_upload:
+            self._upload_trace(trace_id)
         return True
 
     def shutdown(self) -> None:
+        """Upload all pending traces and shutdown."""
+        # Upload all remaining traces
+        trace_ids_to_upload = list(self.trace_spans.keys())
+        for trace_id in trace_ids_to_upload:
+            self._upload_trace(trace_id)
+        
         if hasattr(self, 'task_processor') and self.task_processor is not None:
             self.task_processor.stop()
         logger.info("S3SpanExporter has been shut down.")

monocle_apptrace-0.7.0/src/monocle_apptrace/exporters/azure/blob_exporter.py

@@ -0,0 +1,208 @@
+import os
+import datetime
+import logging
+import asyncio
+from azure.storage.blob import BlobServiceClient, BlobClient, ContainerClient
+from azure.core.exceptions import ResourceNotFoundError, ClientAuthenticationError, ServiceRequestError
+from opentelemetry.sdk.trace import ReadableSpan
+from opentelemetry.sdk.trace.export import SpanExporter, SpanExportResult
+from typing import Sequence, Optional, Dict, List, Tuple
+from monocle_apptrace.exporters.base_exporter import SpanExporterBase, format_trace_id_without_0x
+from monocle_apptrace.exporters.exporter_processor import ExportTaskProcessor
+import json
+from monocle_apptrace.instrumentation.common.constants import MONOCLE_SDK_VERSION
+logger = logging.getLogger(__name__)
+
+HANDLE_TIMEOUT_SECONDS = 60  # 1 minute timeout for orphaned traces
+
+class AzureBlobSpanExporter(SpanExporterBase):
+    def __init__(self, connection_string=None, container_name=None, task_processor: Optional[ExportTaskProcessor] = 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
+        # Dictionary to store spans by trace_id: {trace_id: (spans_list, creation_time, has_root_span)}
+        self.trace_spans: Dict[int, Tuple[List[ReadableSpan], datetime.datetime, bool]] = {}
+        # Use default values if none are provided
+        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')
+
+        self.blob_service_client = BlobServiceClient.from_connection_string(connection_string)
+        self.container_name = container_name
+        self.file_prefix = DEFAULT_FILE_PREFIX
+        self.time_format = DEFAULT_TIME_FORMAT
+
+        # Check if container exists or create it
+        if not self.__container_exists(container_name):
+            try:
+                self.blob_service_client.create_container(container_name)
+                logger.info(f"Container {container_name} created successfully.")
+            except Exception as e:
+                logger.error(f"Error creating container {container_name}: {e}")
+                raise e
+
+        self.task_processor = task_processor
+        if self.task_processor is not None:
+            self.task_processor.start()
+
+    def __container_exists(self, container_name):
+        try:
+            container_client = self.blob_service_client.get_container_client(container_name)
+            container_client.get_container_properties()
+            return True
+        except ResourceNotFoundError:
+            logger.error(f"Container {container_name} not found (404).")
+            return False
+        except ClientAuthenticationError:
+            logger.error(f"Access to container {container_name} is forbidden (403).")
+            raise PermissionError(f"Access to container {container_name} is forbidden.")
+        except Exception as e:
+            logger.error(f"Unexpected error when checking if container {container_name} exists: {e}")
+            raise e
+
+    def _cleanup_expired_traces(self) -> None:
+        """Upload and remove traces that have exceeded the timeout."""
+        current_time = datetime.datetime.now()
+        expired_trace_ids = []
+        
+        for trace_id, (spans, creation_time, _) in self.trace_spans.items():
+            if (current_time - creation_time).total_seconds() > HANDLE_TIMEOUT_SECONDS:
+                expired_trace_ids.append(trace_id)
+        
+        for trace_id in expired_trace_ids:
+            self._upload_trace(trace_id)
+
+    def _add_spans_to_trace(self, trace_id: int, spans: List[ReadableSpan], has_root: bool = False) -> None:
+        """Add spans to a trace buffer, creating it if needed."""
+        if trace_id in self.trace_spans:
+            existing_spans, creation_time, existing_root = self.trace_spans[trace_id]
+            existing_spans.extend(spans)
+            has_root = has_root or existing_root
+            self.trace_spans[trace_id] = (existing_spans, creation_time, has_root)
+        else:
+            self.trace_spans[trace_id] = (spans.copy(), datetime.datetime.now(), has_root)
+
+    def _upload_trace(self, trace_id: int) -> None:
+        """Upload a specific trace to Azure Blob and remove it from the buffer."""
+        if trace_id not in self.trace_spans:
+            return
+        
+        spans, _, _ = self.trace_spans[trace_id]
+        if len(spans) == 0:
+            del self.trace_spans[trace_id]
+            return
+        
+        serialized_data = self.__serialize_spans(spans)
+        if serialized_data:
+            try:
+                self.__upload_to_blob_with_trace_id(serialized_data, trace_id)
+            except Exception as e:
+                logger.error(f"Failed to upload trace {format_trace_id_without_0x(trace_id)}: {e}")
+        
+        del self.trace_spans[trace_id]
+
+    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."""
+        try:
+            # Cleanup expired traces first
+            self._cleanup_expired_traces()
+            
+            # Group spans by trace_id
+            spans_by_trace = {}
+            root_span_traces = set()
+            
+            for span in spans:
+                # Azure blob library has a check to generate it's own span if OpenTelemetry is loaded and Azure trace package is installed (just pip install azure-trace-opentelemetry)
+                # With Monocle,OpenTelemetry is always loaded. If the Azure trace package is installed, then it triggers the blob trace generation on every blob operation.
+                # Thus, the Monocle span write ends up generating a blob span which again comes back to the exporter .. and would result in an infinite loop.
+                # To avoid this, we check if the span has the Monocle SDK version attribute and skip it if it doesn't. That way the blob span genearted by Azure library are not exported.
+                if self.skip_export(span):
+                    continue
+                
+                trace_id = span.context.trace_id
+                if trace_id not in spans_by_trace:
+                    spans_by_trace[trace_id] = []
+                spans_by_trace[trace_id].append(span)
+                
+                # Check if this span is a root span (no parent)
+                if not span.parent:
+                    root_span_traces.add(trace_id)
+            
+            # Add spans to their respective trace buffers
+            for trace_id, trace_spans in spans_by_trace.items():
+                has_root = trace_id in root_span_traces
+                self._add_spans_to_trace(trace_id, trace_spans, has_root)
+            
+            # Upload complete traces (those with root spans)
+            for trace_id in root_span_traces:
+                if self.task_processor is not None and callable(getattr(self.task_processor, 'queue_task', None)):
+                    # Queue the upload task
+                    if trace_id in self.trace_spans:
+                        spans_to_upload, _, _ = self.trace_spans[trace_id]
+                        serialized_data = self.__serialize_spans(spans_to_upload)
+                        if serialized_data:
+                            self.task_processor.queue_task(self.__upload_to_blob_with_trace_id, serialized_data, trace_id)
+                        del self.trace_spans[trace_id]
+                else:
+                    self._upload_trace(trace_id)
+        except Exception as e:
+            logger.error(f"Error in _export_async: {e}")
+
+    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}")
+            return ""
+
+    @SpanExporterBase.retry_with_backoff(exceptions=(ResourceNotFoundError, ClientAuthenticationError, ServiceRequestError))
+    def __upload_to_blob_with_trace_id(self, span_data_batch: str, trace_id: int):
+        """Upload spans for a specific trace to Azure Blob with trace ID in filename."""
+        current_time = datetime.datetime.now().strftime(self.time_format)
+        file_name = f"{self.file_prefix}{current_time}_{format_trace_id_without_0x(trace_id)}.ndjson"
+        blob_client = self.blob_service_client.get_blob_client(container=self.container_name, blob=file_name)
+        blob_client.upload_blob(span_data_batch, overwrite=True)
+        logger.debug(f"Trace {format_trace_id_without_0x(trace_id)} uploaded to Azure Blob Storage as {file_name}.")
+
+    async def force_flush(self, timeout_millis: int = 30000) -> bool:
+        """Flush all pending traces to Azure Blob."""
+        trace_ids_to_upload = list(self.trace_spans.keys())
+        for trace_id in trace_ids_to_upload:
+            self._upload_trace(trace_id)
+        return True
+
+    def shutdown(self) -> None:
+        """Upload all pending traces and shutdown."""
+        # Upload all remaining traces
+        trace_ids_to_upload = list(self.trace_spans.keys())
+        for trace_id in trace_ids_to_upload:
+            self._upload_trace(trace_id)
+        
+        if hasattr(self, 'task_processor') and self.task_processor is not None:
+            self.task_processor.stop()
+        logger.info("AzureBlobSpanExporter has been shut down.")

{monocle_apptrace-0.6.0 → monocle_apptrace-0.7.0}/src/monocle_apptrace/exporters/base_exporter.py

@@ -51,4 +51,13 @@ class SpanExporterBase(ABC):
 
             return wrapper
 
-        return decorator
+        return decorator
+    
+
+def format_trace_id_without_0x(trace_id: int) -> str:
+    """Format trace_id as 32-character lowercase hex string without 0x prefix."""
+    return f"{trace_id:032x}"
+
+def format_span_id_without_0x(span_id: int) -> str:
+    """Format span_id as 16-character lowercase hex string without 0x prefix."""
+    return f"{span_id:016x}"

{monocle_apptrace-0.6.0 → monocle_apptrace-0.7.0}/src/monocle_apptrace/exporters/file_exporter.py

@@ -8,7 +8,7 @@ from typing import Optional, Callable, Sequence, Dict, Tuple
 from opentelemetry.sdk.trace import ReadableSpan
 from opentelemetry.sdk.trace.export import SpanExporter, SpanExportResult
 from opentelemetry.sdk.resources import SERVICE_NAME
-from monocle_apptrace.exporters.base_exporter import SpanExporterBase
+from monocle_apptrace.exporters.base_exporter import SpanExporterBase, format_trace_id_without_0x
 from monocle_apptrace.exporters.exporter_processor import ExportTaskProcessor
 
 DEFAULT_FILE_PREFIX:str = "monocle_trace_"
@@ -25,7 +25,7 @@ class FileSpanExporter(SpanExporterBase):
         time_format = DEFAULT_TIME_FORMAT,
         formatter: Callable[
             [ReadableSpan], str
-        ] = lambda span: span.to_json()
+        ] = lambda span: span.to_json(indent = 4)
         + linesep,
         task_processor: Optional[ExportTaskProcessor] = None
     ):
@@ -80,7 +80,7 @@ class FileSpanExporter(SpanExporterBase):
         
         # Create new handle
         file_path = path.join(self.output_path,
-                             self.file_prefix + service_name + "_" + hex(trace_id) + "_"
+                             self.file_prefix + service_name + "_" + format_trace_id_without_0x(trace_id) + "_"
                              + datetime.now().strftime(self.time_format) + ".json")
         
         try:

{monocle_apptrace-0.6.0 → monocle_apptrace-0.7.0}/src/monocle_apptrace/exporters/okahu/okahu_exporter.py

@@ -63,13 +63,6 @@ class OkahuSpanExporter(SpanExporterBase):
                 continue
             # create a object from serialized span
             obj = json.loads(span.to_json())
-            if obj["parent_id"] is None:
-                obj["parent_id"] = "None"
-            else:
-                obj["parent_id"] = remove_0x_from_start(obj["parent_id"])
-            if obj["context"] is not None:
-                obj["context"]["trace_id"] = remove_0x_from_start(obj["context"]["trace_id"])
-                obj["context"]["span_id"] = remove_0x_from_start(obj["context"]["span_id"])
             span_list["batch"].append(obj)
 
         # Calculate is_root_span by checking if any span has no parent
@@ -110,11 +103,4 @@ class OkahuSpanExporter(SpanExporterBase):
         self._closed = True
 
     def force_flush(self, timeout_millis: int = 30000) -> bool:
-        return True
-
-
-# only removes the first occurrence of 0x from the string
-def remove_0x_from_start(my_str: str):
-    if my_str.startswith("0x"):
-        return my_str.replace("0x", "", 1)
-    return my_str
+        return True