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

monocle_apptrace/__init__.py

@@ -0,0 +1 @@
+from .instrumentation import *

monocle_apptrace/__main__.py

@@ -0,0 +1,19 @@
+import sys, os
+import runpy
+from monocle_apptrace.instrumentation.common.instrumentor import setup_monocle_telemetry
+
+def main():
+    if len(sys.argv) < 2 or not sys.argv[1].endswith(".py"):
+        print("Usage: python -m monocle_apptrace <your-main-module-file> <args>")
+        sys.exit(1)
+    file_name = os.path.basename(sys.argv[1])
+    workflow_name = file_name[:-3]
+    setup_monocle_telemetry(workflow_name=workflow_name)
+    sys.argv.pop(0)
+
+    try:
+        runpy.run_path(path_name=sys.argv[0], run_name="__main__")
+    except Exception as e:
+        print(e)
+if __name__ == "__main__":
+    main()

monocle_apptrace/exporters/aws/s3_exporter.py

@@ -6,43 +6,59 @@ 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
-from typing import Sequence
+from monocle_apptrace.exporters.exporter_processor import ExportTaskProcessor
+from typing import Sequence, Optional
 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, task_processor: Optional[ExportTaskProcessor] = None):
         super().__init__()
         # Use environment variables if credentials are not provided
-        DEFAULT_FILE_PREFIX = "monocle_trace__"
+        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(
-            '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()
+        self.task_processor = task_processor
+        if self.task_processor is not None:
+            self.task_processor.start()
 
         # 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}")
@@ -80,6 +96,7 @@ class S3SpanExporter(SpanExporterBase):
         """Synchronous export method that internally handles async logic."""
         try:
             # Run the asynchronous export logic in an event loop
+            logger.info(f"Exporting {len(spans)} spans to S3.")
             asyncio.run(self.__export_async(spans))
             return SpanExportResult.SUCCESS
         except Exception as e:
@@ -88,6 +105,7 @@ 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
             for span in spans:
                 self.export_queue.append(span)
@@ -130,19 +148,22 @@ class S3SpanExporter(SpanExporterBase):
         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:
-            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)
-
-        except Exception as e:
-            logger.error(f"Failed to upload span batch: {e}")
+        # 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}")
 
+    @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,
@@ -155,4 +176,6 @@ class S3SpanExporter(SpanExporterBase):
         return True
 
     def shutdown(self) -> None:
+        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/exporters/aws/s3_exporter_opendal.py

@@ -0,0 +1,137 @@
+import os
+import time
+import datetime
+import logging
+import asyncio
+from typing import Sequence, Optional
+from opentelemetry.sdk.trace import ReadableSpan
+from opentelemetry.sdk.trace.export import SpanExportResult
+from monocle_apptrace.exporters.base_exporter import SpanExporterBase
+from monocle_apptrace.exporters.exporter_processor import ExportTaskProcessor
+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, 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
+        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"),
+        )
+        
+        self.task_processor = task_processor
+        if self.task_processor is not None:
+            self.task_processor.start()
+
+    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:]
+        
+        # Calculate is_root_span by checking if any span has no parent
+        is_root_span = any(not span.parent for span in batch_to_export)
+        
+        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, is_root_span)
+            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, is_root_span: bool = False):
+        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}. Is root span: {is_root_span}")
+
+        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:
+        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/exporters/azure/blob_exporter.py

@@ -8,13 +8,15 @@ 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
+from typing import Sequence, Optional
 from monocle_apptrace.exporters.base_exporter import SpanExporterBase
+from monocle_apptrace.exporters.exporter_processor import ExportTaskProcessor
 import json
+from monocle_apptrace.instrumentation.common.constants import MONOCLE_SDK_VERSION
 logger = logging.getLogger(__name__)
 
 class AzureBlobSpanExporter(SpanExporterBase):
-    def __init__(self, connection_string=None, container_name=None):
+    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"
@@ -43,6 +45,10 @@ class AzureBlobSpanExporter(SpanExporterBase):
                 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)
@@ -72,6 +78,12 @@ class AzureBlobSpanExporter(SpanExporterBase):
         """The actual async export logic is run here."""
         # Add spans to the export queue
         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 not span.attributes.get(MONOCLE_SDK_VERSION):
+                continue # TODO: All exporters to use same base class and check it there
             self.export_queue.append(span)
             if len(self.export_queue) >= self.max_batch_size:
                 await self.__export_spans()
@@ -104,25 +116,31 @@ class AzureBlobSpanExporter(SpanExporterBase):
         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:
-            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)
-        except Exception as e:
-            logger.error(f"Failed to upload span batch: {e}")
+        
+        # Calculate is_root_span by checking if any span has no parent
+        is_root_span = any(not span.parent for span in batch_to_export)
+        
+        if self.task_processor is not None and callable(getattr(self.task_processor, 'queue_task', None)):
+            self.task_processor.queue_task(self.__upload_to_blob, serialized_data, is_root_span)
+        else:
+            try:
+                self.__upload_to_blob(serialized_data, is_root_span)
+            except Exception as e:
+                logger.error(f"Failed to upload span batch: {e}")
 
-    def __upload_to_blob(self, span_data_batch: str):
+    @SpanExporterBase.retry_with_backoff(exceptions=(ResourceNotFoundError, ClientAuthenticationError, ServiceRequestError))
+    def __upload_to_blob(self, span_data_batch: str, is_root_span: bool = False):
         current_time = datetime.datetime.now().strftime(self.time_format)
         file_name = f"{self.file_prefix}{current_time}.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.info(f"Span batch uploaded to Azure Blob Storage as {file_name}.")
+        logger.info(f"Span batch uploaded to Azure Blob Storage as {file_name}. Is root span: {is_root_span}")
 
     async def force_flush(self, timeout_millis: int = 30000) -> bool:
         await self.__export_spans()
         return True
 
     def shutdown(self) -> None:
+        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/exporters/azure/blob_exporter_opendal.py

@@ -0,0 +1,162 @@
+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, Optional
+from opendal import Operator
+from monocle_apptrace.exporters.base_exporter import SpanExporterBase
+from monocle_apptrace.exporters.exporter_processor import ExportTaskProcessor
+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, 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
+        self.container_name = container_name
+
+        # Default values
+        self.file_prefix = DEFAULT_FILE_PREFIX
+        self.time_format = DEFAULT_TIME_FORMAT
+        self.export_queue = []  # Add this line to initialize export_queue
+        self.last_export_time = time.time()  # Add this line to initialize last_export_time
+
+        # 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}")
+
+        self.task_processor = task_processor
+        if self.task_processor is not None:
+            self.task_processor.start()
+
+    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:]
+        
+        # Calculate is_root_span by checking if any span has no parent
+        is_root_span = any(not span.parent for span in batch_to_export)
+        
+        if self.task_processor is not None and callable(getattr(self.task_processor, 'queue_task', None)):
+            self.task_processor.queue_task(self.__upload_to_opendal, serialized_data, is_root_span)
+        else:
+            try:
+                self.__upload_to_opendal(serialized_data, is_root_span)
+            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, is_root_span: bool = False):
+        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}. Is root span: {is_root_span}")
+        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:
+        if hasattr(self, 'task_processor') and self.task_processor is not None:
+            self.task_processor.stop()
+        logger.info("OpenDALAzureExporter has been shut down.")

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