ragaai-catalyst 2.2.4.1b4__py3-none-any.whl → 2.2.4.1b5__py3-none-any.whl

ragaai_catalyst/tracers/agentic_tracing/upload/session_manager.py

@@ -0,0 +1,124 @@
+import logging
+import os
+import threading
+
+from requests.adapters import HTTPAdapter
+from urllib3.util.retry import Retry
+from urllib3.exceptions import PoolError, MaxRetryError, NewConnectionError
+from requests.exceptions import ConnectionError, Timeout
+from ragaai_catalyst import RagaAICatalyst
+import requests
+
+logger = logging.getLogger(__name__)
+
+
+class SessionManager:
+    """Shared session manager with connection pooling for HTTP requests"""
+    _instance = None
+    _session = None
+    _lock = threading.Lock()
+
+    def __new__(cls):
+        if cls._instance is None:
+            with cls._lock:  # Thread-safe singleton
+                if cls._instance is None:  # Double-check locking
+                    logger.info("Creating new SessionManager singleton instance")
+                    cls._instance = super(SessionManager, cls).__new__(cls)
+                    cls._instance._initialize_session()
+                else:
+                    logger.debug("SessionManager instance already exists, returning existing instance")
+        else:
+            logger.debug("SessionManager instance exists, returning existing instance")
+        return cls._instance
+
+    def _initialize_session(self):
+        """Initialize session with connection pooling and retry strategy"""
+        logger.info("Initializing HTTP session with connection pooling and retry strategy")
+        self._session = requests.Session()
+
+        retry_strategy = Retry(
+            total=3,  # number of retries
+            backoff_factor=0.5,  # wait 0.5, 1, 2... seconds between retries
+            status_forcelist=[500, 502, 503, 504]  # HTTP status codes to retry on
+        )
+
+        adapter = HTTPAdapter(
+            max_retries=retry_strategy,
+            pool_connections=5,  # number of connection pools to cache (per host)
+            pool_maxsize=50,  # maximum number of connections in each pool
+            pool_block=True  # Block/wait when pool is full rather than raising error
+        )
+
+        self._session.mount("http://", adapter)
+        self._session.mount("https://", adapter)
+
+        logger.info("HTTP session initialized successfully with adapters mounted for http:// and https://")
+
+        # Warm up connection pool using RagaAICatalyst.BASE_URL
+        if os.getenv("RAGAAI_CATALYST_BASE_URL") is not None:
+            base_url = os.getenv("RAGAAI_CATALYST_BASE_URL")
+            logger.info(f"Warming up connection pool using RagaAICatalyst.BASE_URL: {base_url}")
+            self.warm_up_connections(base_url)
+        else:
+            logger.warning(f"RAGAAI_CATALYST_BASE_URL {base_url}  not available, skipping connection warmup")
+
+    @property
+    def session(self):
+        if self._session is None:
+            logger.warning("Session accessed but not initialized, reinitializing...")
+            self._initialize_session()
+        return self._session
+
+    def warm_up_connections(self, base_url, num_connections=3):
+        """
+        Warm up the connection pool by making lightweight requests to healthcheck endpoint.
+        This can help prevent RemoteDisconnected errors on initial requests.
+        """
+        if not self._session:
+            return
+
+        # Construct healthcheck URL
+        healthcheck_url = f"{base_url.rstrip('/')}/healthcheck"
+        logger.info(f"Warming up connection pool with {num_connections} connections to {healthcheck_url}")
+
+        for i in range(num_connections):
+            try:
+                # Make a lightweight HEAD request to the healthcheck endpoint to warm up the connection
+                response = self._session.head(healthcheck_url, timeout=5)
+                logger.info(f"Warmup connection {i+1}: Status {response.status_code}")
+            except Exception as e:
+                logger.error(f"Warmup connection {i+1} failed (this is normal): {e}")
+                # Ignore failures during warmup as they're expected
+                continue
+
+        logger.info("Connection pool warmup completed")
+
+    def close(self):
+        """Close the session"""
+        if self._session:
+            logger.info("Closing HTTP session")
+            self._session.close()
+            self._session = None
+            logger.info("HTTP session closed successfully")
+        else:
+            logger.debug("Close called but session was already None")
+
+    def handle_request_exceptions(self, e, operation_name):
+        """Handle common request exceptions with appropriate logging"""
+        logger.error(f"Exception occurred during {operation_name}")
+        if isinstance(e, (PoolError, MaxRetryError)):
+            logger.error(f"Connection pool exhausted during {operation_name}: {e}")
+        elif isinstance(e, NewConnectionError):
+            logger.error(f"Failed to establish new connection during {operation_name}: {e}")
+        elif isinstance(e, ConnectionError):
+            logger.error(f"Connection error during {operation_name}: {e}")
+        elif isinstance(e, Timeout):
+            logger.error(f"Request timeout during {operation_name}: {e}")
+        else:
+            logger.error(f"Unexpected error during {operation_name}: {e}")
+
+
+# Global session manager instance
+logger.info("Creating global SessionManager instance")
+session_manager = SessionManager()
+logger.info(f"Global SessionManager instance created with ID: {id(session_manager)}")

ragaai_catalyst/tracers/agentic_tracing/upload/trace_uploader.py

@@ -22,6 +22,7 @@ from typing import Dict, Any, Optional
 import threading
 import uuid
 
+
 # Set up logging
 log_dir = os.path.join(tempfile.gettempdir(), "ragaai_logs")
 os.makedirs(log_dir, exist_ok=True)
@@ -49,11 +50,13 @@ try:
     from ragaai_catalyst.tracers.agentic_tracing.upload.upload_code import upload_code
     # from ragaai_catalyst.tracers.agentic_tracing.upload.upload_trace_metric import upload_trace_metric
     from ragaai_catalyst.tracers.agentic_tracing.utils.create_dataset_schema import create_dataset_schema_with_trace
+    from ragaai_catalyst.tracers.agentic_tracing.upload.session_manager import session_manager
     from ragaai_catalyst import RagaAICatalyst
     IMPORTS_AVAILABLE = True
 except ImportError:
     logger.warning("RagaAI Catalyst imports not available - running in test mode")
     IMPORTS_AVAILABLE = False
+    session_manager = None
 
 # Define task queue directory
 QUEUE_DIR = os.path.join(tempfile.gettempdir(), "ragaai_tasks")
@@ -72,6 +75,10 @@ _executor_lock = threading.Lock()
 _futures: Dict[str, Any] = {}
 _futures_lock = threading.Lock()
 
+# Dataset creation cache to avoid redundant API calls
+_dataset_cache: Dict[str, Dict[str, Any]] = {}
+_dataset_cache_lock = threading.Lock()
+DATASET_CACHE_DURATION = 600  # 10 minutes in seconds
 
 _cleanup_lock = threading.Lock()
 _last_cleanup = 0
@@ -88,7 +95,7 @@ def get_executor(max_workers=None):
         if _executor is None:
             # Calculate optimal worker count
             if max_workers is None:
-                max_workers = min(32, (os.cpu_count() or 1) * 4)
+                max_workers = min(8, (os.cpu_count() or 1) * 4)
 
             logger.info(f"Creating ThreadPoolExecutor with {max_workers} workers")
             _executor = concurrent.futures.ThreadPoolExecutor(
@@ -110,9 +117,57 @@ def generate_unique_task_id():
     unique_id = str(uuid.uuid4())[:8]  # Short UUID
     return f"task_{int(time.time())}_{os.getpid()}_{counter}_{unique_id}"
 
+def _generate_dataset_cache_key(dataset_name: str, project_name: str, base_url: str) -> str:
+    """Generate a unique cache key for dataset creation"""
+    return f"{dataset_name}#{project_name}#{base_url}"
+
+def _is_dataset_cached(cache_key: str) -> bool:
+    """Check if dataset creation is cached and still valid"""
+    with _dataset_cache_lock:
+        if cache_key not in _dataset_cache:
+            return False
+
+        cache_entry = _dataset_cache[cache_key]
+        cache_time = cache_entry.get('timestamp', 0)
+        current_time = time.time()
+
+        # Check if cache is still valid (within 10 minutes)
+        if current_time - cache_time <= DATASET_CACHE_DURATION:
+            logger.info(f"Dataset creation cache hit for key: {cache_key}")
+            return True
+        else:
+            # Cache expired, remove it
+            logger.info(f"Dataset creation cache expired for key: {cache_key}")
+            del _dataset_cache[cache_key]
+            return False
+
+def _cache_dataset_creation(cache_key: str, response: Any) -> None:
+    """Cache successful dataset creation"""
+    with _dataset_cache_lock:
+        _dataset_cache[cache_key] = {
+            'timestamp': time.time(),
+            'response': response
+        }
+
+def _cleanup_expired_cache_entries() -> None:
+    """Remove expired cache entries"""
+    current_time = time.time()
+    with _dataset_cache_lock:
+        expired_keys = []
+        for cache_key, cache_entry in _dataset_cache.items():
+            cache_time = cache_entry.get('timestamp', 0)
+            if current_time - cache_time > DATASET_CACHE_DURATION:
+                expired_keys.append(cache_key)
+
+        for key in expired_keys:
+            del _dataset_cache[key]
+
+        if expired_keys:
+            logger.info(f"Cleaned up {len(expired_keys)} expired dataset cache entries")
+
 def process_upload(task_id: str, filepath: str, hash_id: str, zip_path: str, 
                   project_name: str, project_id: str, dataset_name: str, 
-                  user_details: Dict[str, Any], base_url: str, timeout=120, fail_on_trace_error=True) -> Dict[str, Any]:
+                  user_details: Dict[str, Any], base_url: str, tracer_type, timeout=120, fail_on_trace_error=True) -> Dict[str, Any]:
     """
     Process a single upload task
     
@@ -165,20 +220,36 @@ def process_upload(task_id: str, filepath: str, hash_id: str, zip_path: str,
             save_task_status(result)
             return result
             
-        # Step 1: Create dataset schema
+        # Step 1: Create dataset schema (with caching)
         logger.info(f"Creating dataset schema for {dataset_name} with base_url: {base_url} and timeout: {timeout}")
-        try:
-            response = create_dataset_schema_with_trace(
-                dataset_name=dataset_name,
-                project_name=project_name,
-                base_url=base_url,
-                user_details=user_details,
-                timeout=timeout
-            )
-            logger.info(f"Dataset schema created: {response}")
-        except Exception as e:
-            logger.error(f"Error creating dataset schema: {e}")
-            # Continue with other steps
+
+        # Generate cache key and check if dataset creation is already cached
+        cache_key = _generate_dataset_cache_key(dataset_name, project_name, base_url)
+
+        if _is_dataset_cached(cache_key):
+            logger.info(f"Dataset schema creation skipped (cached) for {dataset_name}")
+        else:
+            try:
+                # Clean up expired cache entries periodically
+                # _cleanup_expired_cache_entries()
+
+                response = create_dataset_schema_with_trace(
+                    dataset_name=dataset_name,
+                    project_name=project_name,
+                    base_url=base_url,
+                    user_details=user_details,
+                    timeout=timeout
+                )
+                logger.info(f"Dataset schema created: {response}")
+
+                # Cache the response only if status code is 200
+                if response and hasattr(response, 'status_code') and response.status_code in [200, 201]:
+                    _cache_dataset_creation(cache_key, response)
+                    logger.info(f"Response cached successfully for dataset: {dataset_name} and key: {cache_key}")
+
+            except Exception as e:
+                logger.error(f"Error creating dataset schema: {e}")
+                # Continue with other steps
             
         # Step 2: Upload trace metrics
         # if filepath and os.path.exists(filepath):
@@ -238,28 +309,34 @@ def process_upload(task_id: str, filepath: str, hash_id: str, zip_path: str,
                 logger.error(error_msg)
         
         # Step 4: Upload code hash
-        if hash_id and zip_path and os.path.exists(zip_path):
-            logger.info(f"Uploading code hash {hash_id} with base_url: {base_url} and timeout: {timeout}")
-            try:
-                response = upload_code(
-                    hash_id=hash_id,
-                    zip_path=zip_path,
-                    project_name=project_name,
-                    dataset_name=dataset_name,
-                    base_url=base_url,
-                    timeout=timeout
-                )
-                logger.info(f"Code hash uploaded: {response}")
-            except Exception as e:
-                logger.error(f"Error uploading code hash: {e}")
-        else:
-            logger.warning(f"Code zip {zip_path} not found, skipping code upload")
-        
+        if tracer_type.startswith("agentic/"):
+            logger.info(f"Tracer type '{tracer_type}' matches agentic pattern, proceeding with code upload")
+            if hash_id and zip_path and os.path.exists(zip_path):
+                logger.info(f"Uploading code hash {hash_id} with base_url: {base_url} and timeout: {timeout}")
+                try:
+                    response = upload_code(
+                        hash_id=hash_id,
+                        zip_path=zip_path,
+                        project_name=project_name,
+                        dataset_name=dataset_name,
+                        base_url=base_url,
+                        timeout=timeout
+                    )
+                    if response is None:
+                        error_msg = "Code hash not uploaded"
+                        logger.error(error_msg)
+                    else:
+                        logger.info(f"Code hash uploaded successfully: {response}")
+                except Exception as e:
+                    logger.error(f"Error uploading code hash: {e}")
+            else:
+                logger.warning(f"Code zip {zip_path} not found, skipping code upload")
+
         # Mark task as completed
         result["status"] = STATUS_COMPLETED
         result["end_time"] = datetime.now().isoformat()
         logger.info(f"Task {task_id} completed successfully")
-        
+
     except Exception as e:
         logger.error(f"Error processing task {task_id}: {e}")
         result["status"] = STATUS_FAILED
@@ -302,7 +379,8 @@ def save_task_status(task_status: Dict[str, Any]):
     with open(status_path, "w") as f:
         json.dump(task_status, f, indent=2)
 
-def submit_upload_task(filepath, hash_id, zip_path, project_name, project_id, dataset_name, user_details, base_url, timeout=120):
+def submit_upload_task(filepath, hash_id, zip_path, project_name, project_id, dataset_name, user_details, base_url,
+                       tracer_type, timeout=120):
     """
     Submit a new upload task using futures.
     
@@ -349,6 +427,7 @@ def submit_upload_task(filepath, hash_id, zip_path, project_name, project_id, da
                 dataset_name=dataset_name,
                 user_details=user_details,
                 base_url=base_url,
+                tracer_type = tracer_type,
                 timeout=timeout,
                 fail_on_trace_error=True
             )
@@ -379,6 +458,7 @@ def submit_upload_task(filepath, hash_id, zip_path, project_name, project_id, da
             dataset_name=dataset_name,
             user_details=user_details,
             base_url=base_url,
+            tracer_type=tracer_type,
             timeout=timeout,
             fail_on_trace_error=True
         )
@@ -550,6 +630,14 @@ def shutdown(timeout=120):
 
     _executor = None
 
+    # Close the session manager to clean up HTTP connections
+    if session_manager is not None:
+        try:
+            session_manager.close()
+            logger.info("Session manager closed successfully")
+        except Exception as e:
+            logger.error(f"Error closing session manager: {e}")
+
 # Register shutdown handler
 atexit.register(shutdown)
 

ragaai_catalyst/tracers/agentic_tracing/upload/upload_agentic_traces.py

@@ -4,13 +4,13 @@ import os
 import re
 import time
 from urllib.parse import urlparse, urlunparse
+from urllib3.exceptions import PoolError, MaxRetryError, NewConnectionError
+from requests.exceptions import ConnectionError, Timeout, RequestException
+from .session_manager import session_manager
 
 import requests
 
 logger = logging.getLogger(__name__)
-logging_level = (
-    logger.setLevel(logging.DEBUG) if os.getenv("DEBUG") == "1" else logging.INFO
-)
 
 from ragaai_catalyst.ragaai_catalyst import RagaAICatalyst
 
@@ -47,42 +47,36 @@ class UploadAgenticTraces:
             "X-Project-Name": self.project_name,
         }
 
-        logger.debug("Started getting presigned url: ")
-        logger.debug(f"Payload: {payload}")
-        logger.debug(f"Headers: {headers}")
         try:
             start_time = time.time()
             endpoint = f"{self.base_url}/v1/llm/presigned-url"
             # Changed to POST from GET
-            response = requests.request(
+            response = session_manager.session.request(
                 "POST", endpoint, headers=headers, data=payload, timeout=self.timeout
             )
             elapsed_ms = (time.time() - start_time) * 1000
             logger.debug(
                 f"API Call: [POST] {endpoint} | Status: {response.status_code} | Time: {elapsed_ms:.2f}ms"
             )
-            if response.status_code in [200, 201]:
+
+            if response.status_code == 200:
                 presignedURLs = response.json()["data"]["presignedUrls"][0]
-                logger.debug(f"Got presigned url: {presignedURLs}")
                 presignedurl = self.update_presigned_url(presignedURLs, self.base_url)
-                logger.debug(f"Updated presigned url: {presignedurl}")
                 return presignedurl
             else:
                 # If POST fails, try GET
-                response = requests.request(
+                response = session_manager.session.request(
                     "GET", endpoint, headers=headers, data=payload, timeout=self.timeout
                 )
                 elapsed_ms = (time.time() - start_time) * 1000
                 logger.debug(
                     f"API Call: [GET] {endpoint} | Status: {response.status_code} | Time: {elapsed_ms:.2f}ms"
                 )
-                if response.status_code in [200, 201]:
+                if response.status_code == 200:
                     presignedURLs = response.json()["data"]["presignedUrls"][0]
-                    logger.debug(f"Got presigned url: {presignedURLs}")
                     presignedurl = self.update_presigned_url(
                         presignedURLs, self.base_url
                     )
-                    logger.debug(f"Updated presigned url: {presignedurl}")
                     return presignedurl
                 elif response.status_code == 401:
                     logger.warning("Received 401 error. Attempting to refresh token.")
@@ -92,7 +86,7 @@ class UploadAgenticTraces:
                         "Authorization": f"Bearer {token}",
                         "X-Project-Name": self.project_name,
                     }
-                    response = requests.request(
+                    response = session_manager.session.request(
                         "POST",
                         endpoint,
                         headers=headers,
@@ -103,13 +97,11 @@ class UploadAgenticTraces:
                     logger.debug(
                         f"API Call: [POST] {endpoint} | Status: {response.status_code} | Time: {elapsed_ms:.2f}ms"
                     )
-                    if response.status_code in [200, 201]:
+                    if response.status_code == 200:
                         presignedURLs = response.json()["data"]["presignedUrls"][0]
-                        logger.debug(f"Got presigned url: {presignedURLs}")
                         presignedurl = self.update_presigned_url(
                             presignedURLs, self.base_url
                         )
-                        logger.debug(f"Updated presigned url: {presignedurl}")
                         return presignedurl
                     else:
                         logger.error(
@@ -121,8 +113,10 @@ class UploadAgenticTraces:
                         f"Error while getting presigned url: {response.json()['message']}"
                     )
                     return None
-
-        except requests.exceptions.RequestException as e:
+        except (PoolError, MaxRetryError, NewConnectionError, ConnectionError, Timeout) as e:
+            session_manager.handle_request_exceptions(e, "getting presigned URL")
+            return None
+        except RequestException as e:
             logger.error(f"Error while getting presigned url: {e}")
             return None
 
@@ -149,16 +143,16 @@ class UploadAgenticTraces:
 
         if "blob.core.windows.net" in presignedUrl:  # Azure
             headers["x-ms-blob-type"] = "BlockBlob"
-        print("Uploading agentic traces...")
+        logger.info("Uploading agentic traces to presigned URL...")
         try:
             with open(filename) as f:
                 payload = f.read().replace("\n", "").replace("\r", "").encode()
         except Exception as e:
-            print(f"Error while reading file: {e}")
+            logger.error(f"Error while reading file: {e}")
             return False
         try:
             start_time = time.time()
-            response = requests.request(
+            response = session_manager.session.request(
                 "PUT", presignedUrl, headers=headers, data=payload, timeout=self.timeout
             )
             elapsed_ms = (time.time() - start_time) * 1000
@@ -168,8 +162,11 @@ class UploadAgenticTraces:
             if response.status_code != 200 or response.status_code != 201:
                 return response, response.status_code
             return True
-        except requests.exceptions.RequestException as e:
-            print(f"Error while uploading to presigned url: {e}")
+        except (PoolError, MaxRetryError, NewConnectionError, ConnectionError, Timeout) as e:
+            session_manager.handle_request_exceptions(e, "uploading trace to presigned URL")
+            return False
+        except RequestException as e:
+            logger.error(f"Error while uploading trace to presigned url: {e}")
             return False
 
     def insert_traces(self, presignedUrl):
@@ -185,21 +182,18 @@ class UploadAgenticTraces:
                 "datasetSpans": self._get_dataset_spans(),  # Extra key for agentic traces
             }
         )
-        logger.debug(f"Inserting agentic traces to presigned url: {presignedUrl}")
         try:
             start_time = time.time()
             endpoint = f"{self.base_url}/v1/llm/insert/trace"
-            response = requests.request(
+            response = session_manager.session.request(
                 "POST", endpoint, headers=headers, data=payload, timeout=self.timeout
             )
-            logger.debug(f"Payload: {payload}")
-            logger.debug(f"Headers: {headers}")
             elapsed_ms = (time.time() - start_time) * 1000
             logger.debug(
                 f"API Call: [POST] {endpoint} | Status: {response.status_code} | Time: {elapsed_ms:.2f}ms"
             )
             if response.status_code in [200, 201]:
-                logger.debug("Successfully inserted traces")
+                logger.info(f"Traces inserted successfully: {response.json()['message']}")
                 return True
             elif response.status_code == 401:
                 logger.warning("Received 401 error. Attempting to refresh token.")
@@ -209,7 +203,7 @@ class UploadAgenticTraces:
                     "Content-Type": "application/json",
                     "X-Project-Name": self.project_name,
                 }
-                response = requests.request(
+                response = session_manager.session.request(
                     "POST",
                     endpoint,
                     headers=headers,
@@ -221,24 +215,27 @@ class UploadAgenticTraces:
                     f"API Call: [POST] {endpoint} | Status: {response.status_code} | Time: {elapsed_ms:.2f}ms"
                 )
                 if response.status_code in [200, 201]:
-                    logger.debug("Successfully inserted traces")
+                    logger.info(f"Traces inserted successfully: {response.json()['message']}")
                     return True
                 else:
-                    logger.debug("Error while inserting traces")
+                    logger.error(f"Error while inserting traces after 401: {response.json()['message']}")
                     return False
             else:
-                logger.debug("Error while inserting traces")
+                logger.error(f"Error while inserting traces: {response.json()['message']}")
                 return False
-        except requests.exceptions.RequestException as e:
-            logger.debug(f"Error while inserting traces: {e}")
-            return None
+        except (PoolError, MaxRetryError, NewConnectionError, ConnectionError, Timeout) as e:
+            session_manager.handle_request_exceptions(e, "inserting traces")
+            return False
+        except RequestException as e:
+            logger.error(f"Error while inserting traces: {e}")
+            return False
 
     def _get_dataset_spans(self):
         try:
             with open(self.json_file_path) as f:
                 data = json.load(f)
         except Exception as e:
-            logger.debug(f"Error while reading file: {e}")
+            print(f"Error while reading file: {e}")
             return None
         try:
             spans = data["data"][0]["spans"]
@@ -260,41 +257,41 @@ class UploadAgenticTraces:
                     continue
             return dataset_spans
         except Exception as e:
-            logger.debug(f"Error while reading dataset spans: {e}")
+            logger.error(f"Error while reading dataset spans: {e}")
             return None
 
     def upload_agentic_traces(self):
         try:
             presigned_url = self._get_presigned_url()
             if presigned_url is None:
-                logger.debug("Warning: Failed to obtain presigned URL")
+                logger.warning("Warning: Failed to obtain presigned URL")
                 return False
 
             # Upload the file using the presigned URL
             upload_result = self._put_presigned_url(presigned_url, self.json_file_path)
             if not upload_result:
-                logger.debug("Error: Failed to upload file to presigned URL")
+                logger.error("Error: Failed to upload file to presigned URL")
                 return False
             elif isinstance(upload_result, tuple):
                 response, status_code = upload_result
                 if status_code not in [200, 201]:
-                    logger.debug(
-                        f"Error: Upload failed with status code {status_code}: {response.text if hasattr(response, 'text') else 'Unknown error'}")
+                    logger.error(
+                        f"Error: Uploading agentic traces failed with status code {status_code}: {response.text if hasattr(response, 'text') else 'Unknown error'}")
                     return False
             # Insert trace records
             insert_success = self.insert_traces(presigned_url)
             if not insert_success:
-                logger.debug("Error: Failed to insert trace records")
+                print("Error: Failed to insert trace records")
                 return False
 
-            logger.debug("Successfully uploaded agentic traces")
+            logger.info("Successfully uploaded agentic traces")
             return True
         except FileNotFoundError:
-            logger.debug(f"Error: Trace file not found at {self.json_file_path}")
+            logger.error(f"Error: Trace file not found at {self.json_file_path}")
             return False
         except ConnectionError as e:
-            logger.debug(f"Error: Network connection failed while uploading traces: {e}")
+            logger.error(f"Error: Network connection failed while uploading traces: {e}")
             return False
         except Exception as e:
-            logger.debug(f"Error while uploading agentic traces: {e}")
+            logger.error(f"Error while uploading agentic traces: {e}")
             return False

ragaai_catalyst/tracers/agentic_tracing/upload/upload_code.py

@@ -1,15 +1,18 @@
-import json
 import logging
 import os
 import time
+import re
+import json
+from urllib.parse import urlparse, urlunparse
+from urllib3.exceptions import PoolError, MaxRetryError, NewConnectionError
+from requests.exceptions import ConnectionError, Timeout, RequestException
 
 import requests
 
 from ragaai_catalyst.ragaai_catalyst import RagaAICatalyst
+from .session_manager import session_manager
 
 logger = logging.getLogger(__name__)
-import re
-from urllib.parse import urlparse, urlunparse
 
 
 def upload_code(
@@ -19,11 +22,26 @@ def upload_code(
         project_name, dataset_name, base_url, timeout=timeout
     )
 
+    # Handle None case during exceptions - do not proceed
+    if code_hashes_list is None:
+        logger.error("Failed to fetch existing code hashes, cannot proceed with upload")
+        return None
+
     if hash_id not in code_hashes_list:
         presigned_url = _fetch_presigned_url(
             project_name, dataset_name, base_url, timeout=timeout
         )
-        _put_zip_presigned_url(project_name, presigned_url, zip_path, timeout=timeout)
+        # Handle None case for presigned URL
+        if presigned_url is None:
+            logger.error("Failed to fetch presigned URL, cannot proceed with upload")
+            return None
+
+        upload_result = _put_zip_presigned_url(project_name, presigned_url, zip_path, timeout=timeout)
+
+        # Handle upload failure
+        if upload_result is False or (isinstance(upload_result, tuple) and upload_result[1] not in [200, 201]):
+            logger.error("Failed to upload zip file")
+            return None
 
         response = _insert_code(
             dataset_name,
@@ -33,6 +51,10 @@ def upload_code(
             base_url,
             timeout=timeout,
         )
+        # Handle None response from insert_code
+        if response is None:
+            logger.error("Failed to insert code metadata")
+            return None
         return response
     else:
         return "Code already exists"
@@ -49,7 +71,7 @@ def _fetch_dataset_code_hashes(project_name, dataset_name, base_url=None, timeou
         url_base = base_url if base_url is not None else RagaAICatalyst.BASE_URL
         start_time = time.time()
         endpoint = f"{url_base}/v2/llm/dataset/code?datasetName={dataset_name}"
-        response = requests.request(
+        response = session_manager.session.request(
             "GET", endpoint, headers=headers, data=payload, timeout=timeout
         )
         elapsed_ms = (time.time() - start_time) * 1000
@@ -57,7 +79,7 @@ def _fetch_dataset_code_hashes(project_name, dataset_name, base_url=None, timeou
             f"API Call: [GET] {endpoint} | Status: {response.status_code} | Time: {elapsed_ms:.2f}ms"
         )
 
-        if response.status_code == 200:
+        if response.status_code in [200, 201]:
             return response.json()["data"]["codeHashes"]
         elif response.status_code == 401:
             logger.warning("Received 401 error. Attempting to refresh token.")
@@ -66,22 +88,25 @@ def _fetch_dataset_code_hashes(project_name, dataset_name, base_url=None, timeou
                 "Authorization": f"Bearer {os.getenv('RAGAAI_CATALYST_TOKEN')}",
                 "X-Project-Name": project_name,
             }
-            response = requests.request(
+            response = session_manager.session.request(
                 "GET", endpoint, headers=headers, data=payload, timeout=timeout
             )
             elapsed_ms = (time.time() - start_time) * 1000
-            logger.debug(
-                f"API Call: [GET] {endpoint} | Status: {response.status_code} | Time: {elapsed_ms:.2f}ms"
-            )
-            if response.status_code == 200:
+            logger.debug(f"API Call: [GET] {endpoint} | Status: {response.status_code} | Time: {elapsed_ms:.2f}ms")
+            if response.status_code in [200, 201]:
                 return response.json()["data"]["codeHashes"]
             else:
-                logger.error(
-                    f"Failed to fetch code hashes: {response.json()['message']}"
-                )
-    except requests.exceptions.RequestException as e:
+                logger.error(f"Failed to fetch code hashes: {response.json()['message']}")
+                return None
+        else:
+            logger.error(f"Error while fetching dataset code hashes: {response.json()['message']}")
+            return None
+    except (PoolError, MaxRetryError, NewConnectionError, ConnectionError, Timeout) as e:
+        session_manager.handle_request_exceptions(e, "fetching dataset code hashes")
+        return None
+    except RequestException as e:
         logger.error(f"Failed to list datasets: {e}")
-        pass
+        return None
 
 
 def update_presigned_url(presigned_url, base_url):
@@ -156,7 +181,7 @@ def _fetch_presigned_url(project_name, dataset_name, base_url=None, timeout=120)
                 logger.debug(
                     f"API Call: [POST] {endpoint} | Status: {response.status_code} | Time: {elapsed_ms:.2f}ms"
                 )
-                if response.status_code == 200:
+                if response.status_code in [200, 201]:
                     presigned_url = response.json()["data"]["presignedUrls"][0]
                     presigned_url = update_presigned_url(presigned_url, url_base)
                     return presigned_url
@@ -168,9 +193,10 @@ def _fetch_presigned_url(project_name, dataset_name, base_url=None, timeout=120)
                 logger.error(
                     f"Failed to fetch code hashes: {response.json()['message']}"
                 )
+                return None
     except requests.exceptions.RequestException as e:
         logger.error(f"Failed to list datasets: {e}")
-        pass
+        return None
 
 
 def _put_zip_presigned_url(project_name, presignedUrl, filename, timeout=120):
@@ -181,21 +207,28 @@ def _put_zip_presigned_url(project_name, presignedUrl, filename, timeout=120):
 
     if "blob.core.windows.net" in presignedUrl:  # Azure
         headers["x-ms-blob-type"] = "BlockBlob"
-    print("Uploading code...")
-    with open(filename, "rb") as f:
-        payload = f.read()
-
-    start_time = time.time()
-    response = requests.request(
-        "PUT", presignedUrl, headers=headers, data=payload, timeout=timeout
-    )
-    elapsed_ms = (time.time() - start_time) * 1000
-    logger.debug(
-        f"API Call: [PUT] {presignedUrl} | Status: {response.status_code} | Time: {elapsed_ms:.2f}ms"
-    )
-    if response.status_code != 200 or response.status_code != 201:
-        return response, response.status_code
+    logger.info("Uploading code to presigned URL...")
+    try:
+        with open(filename, "rb") as f:
+            payload = f.read()
 
+        start_time = time.time()
+        response = session_manager.session.request(
+            "PUT", presignedUrl, headers=headers, data=payload, timeout=timeout
+        )
+        elapsed_ms = (time.time() - start_time) * 1000
+        logger.debug(
+            f"API Call: [PUT] {presignedUrl} | Status: {response.status_code} | Time: {elapsed_ms:.2f}ms"
+        )
+        if response.status_code not in [200, 201]:
+            return response, response.status_code
+        return True
+    except (PoolError, MaxRetryError, NewConnectionError, ConnectionError, Timeout) as e:
+        session_manager.handle_request_exceptions(e, "uploading zip to presigned URL")
+        return False
+    except RequestException as e:
+        logger.error(f"Failed to upload zip: {e}")
+        return False
 
 def _insert_code(
     dataset_name, hash_id, presigned_url, project_name, base_url=None, timeout=120
@@ -218,39 +251,43 @@ def _insert_code(
         url_base = base_url if base_url is not None else RagaAICatalyst.BASE_URL
         start_time = time.time()
         endpoint = f"{url_base}/v2/llm/dataset/code"
-        response = requests.request(
+        response = session_manager.session.request(
             "POST", endpoint, headers=headers, data=payload, timeout=timeout
         )
         elapsed_ms = (time.time() - start_time) * 1000
         logger.debug(
             f"API Call: [POST] {endpoint} | Status: {response.status_code} | Time: {elapsed_ms:.2f}ms"
         )
-        if response.status_code == 200:
+        if response.status_code in [200, 201]:
             return response.json()["message"]
 
         elif response.status_code == 401:
-            logger.warning("Received 401 error. Attempting to refresh token.")
+            logger.warning("Received 401 error during inserting code. Attempting to refresh token.")
             token = RagaAICatalyst.get_token(force_refresh=True)
             headers = {
                 "X-Project-Name": project_name,
                 "Content-Type": "application/json",
                 "Authorization": f"Bearer {token}",
             }
-            response = requests.request(
+            response = session_manager.session.request(
                 "POST", endpoint, headers=headers, data=payload, timeout=timeout
             )
             elapsed_ms = (time.time() - start_time) * 1000
             logger.debug(
                 f"API Call: [POST] {endpoint} | Status: {response.status_code} | Time: {elapsed_ms:.2f}ms"
             )
-            if response.status_code == 200:
+            if response.status_code in [200, 201]:
+                logger.info(f"Code inserted successfully after 401: {response.json()['message']}")
                 return response.json()["message"]
             else:
-                logger.error(f"Failed to insert code: {response.json()['message']}")
-                pass
+                logger.error(f"Failed to insert code after 401: {response.json()['message']}")
+                return None
         else:
             logger.error(f"Failed to insert code: {response.json()['message']}")
-            pass
-    except requests.exceptions.RequestException as e:
+            return None
+    except (PoolError, MaxRetryError, NewConnectionError, ConnectionError, Timeout) as e:
+        session_manager.handle_request_exceptions(e, "inserting code")
+        return None
+    except RequestException as e:
         logger.error(f"Failed to insert code: {e}")
-        pass
+        return None

ragaai_catalyst/tracers/exporters/ragaai_trace_exporter.py

@@ -19,7 +19,7 @@ from ragaai_catalyst.tracers.agentic_tracing.utils.zip_list_of_unique_files impo
 )
 from ragaai_catalyst.tracers.utils.trace_json_converter import convert_json_format
 
-logger = logging.getLogger(__name__)
+logger = logging.getLogger("RagaAICatalyst")
 logging_level = (
     logger.setLevel(logging.DEBUG) if os.getenv("DEBUG") == "1" else logging.INFO
 )
@@ -46,7 +46,6 @@ class RAGATraceExporter(SpanExporter):
         self.external_id = external_id
 
     def export(self, spans):
-        logger.debug("Starting export of span: ")
         for span in spans:
             try:
                 span_json = json.loads(span.to_json())
@@ -61,11 +60,8 @@ class RAGATraceExporter(SpanExporter):
 
                 if span_json["parent_id"] is None:
                     trace = self.trace_spans[trace_id]
-                    logger.debug("End of trace found: ")
                     try:
-                        logger.debug("Started processing complete trace: ")
                         self.process_complete_trace(trace, trace_id)
-                        logger.debug("Completed processing complete trace: ")
                     except Exception as e:
                         logger.error(f"Error processing complete trace: {e}")
                     try:
@@ -88,11 +84,9 @@ class RAGATraceExporter(SpanExporter):
     def process_complete_trace(self, spans, trace_id):
         # Convert the trace to ragaai trace format
         try:
-            logger.debug("Started preparing trace to trace format: ")
             ragaai_trace_details = self.prepare_trace(spans, trace_id)
-            logger.debug("Completed preparing trace to trace format: ")
         except Exception as e:
-            logger.error(f"Error preparing trace {trace_id}: {e}")
+            print(f"Error converting trace {trace_id}: {e}")
             return  # Exit early if conversion fails
 
         # Check if trace details are None (conversion failed)
@@ -102,118 +96,98 @@ class RAGATraceExporter(SpanExporter):
             
         # Upload the trace if upload_trace function is provided
         try:
-            logger.debug("Started uploading trace: ")
             if self.post_processor!=None:
                 ragaai_trace_details['trace_file_path'] = self.post_processor(ragaai_trace_details['trace_file_path'])
             self.upload_trace(ragaai_trace_details, trace_id)
-            logger.debug("Completed uploading trace: ")
         except Exception as e:
-            logger.error(f"Error uploading trace {trace_id}: {e}")
+            print(f"Error uploading trace {trace_id}: {e}")
 
     def prepare_trace(self, spans, trace_id):
         try:
             try:
-                logger.debug("Started converting trace to trace format: ")
                 ragaai_trace = convert_json_format(spans, self.custom_model_cost, self.user_context, self.user_gt,self.external_id)   
-                logger.debug("Completed converting trace to trace format: ")
             except Exception as e:
-                logger.error(f"Error in convert_json_format function: {trace_id}: {e}")
+                print(f"Error in convert_json_format function: {trace_id}: {e}")
                 return None
             
             try:
-                logger.debug("Started formatting interactions: ")
                 interactions = format_interactions(ragaai_trace)         
                 ragaai_trace["workflow"] = interactions['workflow']
-                logger.debug("Completed formatting interactions: ")
             except Exception as e:
-                logger.error(f"Error in format_interactions function: {trace_id}: {e}")
+                print(f"Error in format_interactions function: {trace_id}: {e}")
                 return None
 
-            # try:
-            #     logger.debug("Started zipping source code: ")
-            #     # Add source code hash
-            #     hash_id, zip_path = zip_list_of_unique_files(
-            #         self.files_to_zip, output_dir=self.tmp_dir
-            #     )
-            #     logger.debug("Completed zipping source code: ")
-            # except Exception as e:
-            #     logger.error(f"Error in zip_list_of_unique_files function: {trace_id}: {e}")
-            #     return None
+            try:
+                # Add source code hash
+                hash_id, zip_path = zip_list_of_unique_files(
+                    self.files_to_zip, output_dir=self.tmp_dir
+                )
+            except Exception as e:
+                print(f"Error in zip_list_of_unique_files function: {trace_id}: {e}")
+                return None
 
             try:
-                logger.debug("Started adding system info: ")
                 ragaai_trace["metadata"]["system_info"] = asdict(self.system_monitor.get_system_info())
                 ragaai_trace["metadata"]["resources"] = asdict(self.system_monitor.get_resources())
-                logger.debug("Completed adding system info: ")
             except Exception as e:
-                logger.error(f"Error in get_system_info or get_resources function: {trace_id}: {e}")
+                print(f"Error in get_system_info or get_resources function: {trace_id}: {e}")
                 return None
 
             try:
-                logger.debug("Started adding source code hash: ")
-                ragaai_trace["metadata"]["system_info"]["source_code"] = ""
-                logger.debug("Completed adding source code hash: ")
+                ragaai_trace["metadata"]["system_info"]["source_code"] = hash_id
             except Exception as e:
-                logger.error(f"Error in adding source code hash: {trace_id}: {e}")
+                print(f"Error in adding source code hash: {trace_id}: {e}")
                 return None
 
             try:
                 ragaai_trace["data"][0]["start_time"] = ragaai_trace["start_time"]
                 ragaai_trace["data"][0]["end_time"] = ragaai_trace["end_time"]
             except Exception as e:
-                logger.error(f"Error in adding start_time or end_time: {trace_id}: {e}")
+                print(f"Error in adding start_time or end_time: {trace_id}: {e}")
                 return None
 
             try:
-                logger.debug("Started adding project name: ")
                 ragaai_trace["project_name"] = self.project_name
-                logger.debug("Completed adding project name: ")
             except Exception as e:
-                logger.error(f"Error in adding project name: {trace_id}: {e}")
+                print(f"Error in adding project name: {trace_id}: {e}")
                 return None
 
             try:
-                logger.debug("Started adding tracer type: ")
                 # Add tracer type to the trace
                 ragaai_trace["tracer_type"] = self.tracer_type
-                logger.debug("Completed adding tracer type: ")
             except Exception as e:
-                logger.error(f"Error in adding tracer type: {trace_id}: {e}")
+                print(f"Error in adding tracer type: {trace_id}: {e}")
                 return None
             
             #Add user passed metadata to the trace
             try:
-                logger.debug("Started adding user passed metadata: ")
                 if self.user_details.get("trace_user_detail").get("metadata") and isinstance(self.user_details.get("trace_user_detail").get("metadata"), dict):
                     for key, value in self.user_details.get("trace_user_detail").get("metadata").items():
                         if key in ["log_source", "recorded_on"]:
                             continue
                         ragaai_trace["metadata"][key] = value
-                logger.debug("Completed adding user passed metadata: ")
             except Exception as e:
-                logger.error(f"Error in adding metadata: {trace_id}: {e}")
+                print(f"Error in adding metadata: {trace_id}: {e}")
                 return None
             
             try:
-                logger.debug("Started saving trace json: ")
                 # Save the trace_json 
                 trace_file_path = os.path.join(self.tmp_dir, f"{trace_id}.json")
                 with open(trace_file_path, "w") as file:
                     json.dump(ragaai_trace, file, cls=TracerJSONEncoder, indent=2)
                 with open(os.path.join(os.getcwd(), 'rag_agent_traces.json'), 'w') as f:
                     json.dump(ragaai_trace, f, cls=TracerJSONEncoder, indent=2)
-                logger.debug("Completed saving trace json: ")
             except Exception as e:
-                logger.error(f"Error in saving trace json: {trace_id}: {e}")
+                print(f"Error in saving trace json: {trace_id}: {e}")
                 return None
 
             return {
                 'trace_file_path': trace_file_path,
-                'code_zip_path': "zip_path",
-                'hash_id': "absdsjkdhsjkfhjkdshfkjdshfjdsh"
+                'code_zip_path': zip_path,
+                'hash_id': hash_id
             }
         except Exception as e:
-            logger.error(f"Error converting trace {trace_id}: {str(e)}")
+            print(f"Error converting trace {trace_id}: {str(e)}")
             return None
 
     def upload_trace(self, ragaai_trace_details, trace_id):
@@ -229,6 +203,7 @@ class RAGATraceExporter(SpanExporter):
                 dataset_name=self.dataset_name,
                 user_details=self.user_details,
                 base_url=self.base_url,
+                tracer_type=self.tracer_type,
                 timeout=self.timeout
             )
 

ragaai_catalyst/tracers/tracer.py

@@ -127,11 +127,9 @@ class Tracer(AgenticTracing):
         self.model_custom_cost = {}
         super().__init__(user_detail=user_detail, auto_instrumentation=auto_instrumentation)
 
-        logger.debug(f"Setting up Tracer instance with project: {project_name}, dataset: {dataset_name}")
         self.project_name = project_name
         self.dataset_name = dataset_name
         self.tracer_type = tracer_type
-        logger.debug(f"Tracer type set to: {tracer_type}")
         self.metadata = self._improve_metadata(metadata, tracer_type)
         # self.metadata["total_cost"] = 0.0
         # self.metadata["total_tokens"] = 0
@@ -148,16 +146,12 @@ class Tracer(AgenticTracing):
         self.file_tracker = TrackName()
         self.post_processor = None
         self.max_upload_workers = max_upload_workers
-        logger.debug(f"Max upload workers: {self.max_upload_workers}")
         self.user_details = self._pass_user_data()
         self.update_llm_cost = update_llm_cost
         self.auto_instrumentation = auto_instrumentation
         self.external_id = external_id
-        if external_id:
-            logger.debug(f"External ID provided: {external_id}")
         
         try:
-            logger.debug(f"Fetching projects list from {self.base_url}/v2/llm/projects")
             response = requests.get(
                 f"{self.base_url}/v2/llm/projects?size={self.num_projects}",
                 headers={
@@ -171,13 +165,8 @@ class Tracer(AgenticTracing):
             project_list = [
                 project["name"] for project in response.json()["data"]["content"]
             ]
-            logger.debug(f"Found {len(project_list)} projects")
             if project_name not in project_list:
-                logger.warning(f"Project '{project_name}' not found in available projects")
-                logger.debug(f"Available projects: {project_list}")
-            else:
-                logger.debug(f"Project '{project_name}' found in available projects")
-                
+                logger.error("Project not found. Please enter a valid project name")
             
             self.project_id = [
                 project["id"] for project in response.json()["data"]["content"] if project["name"] == project_name
@@ -188,7 +177,6 @@ class Tracer(AgenticTracing):
 
         except requests.exceptions.RequestException as e:
             logger.error(f"Failed to retrieve projects list: {e}")
-            logger.debug(f"Request exception details: {str(e)}, URL: {self.base_url}/v2/llm/projects")
 
         # if tracer_type == "langchain":
         #     instrumentors = []
@@ -203,16 +191,13 @@ class Tracer(AgenticTracing):
         #     from openinference.instrumentation.langchain import LangChainInstrumentor
         #     instrumentors += [(LangChainInstrumentor, [])]
         #     self._setup_agentic_tracer(instrumentors)
-
         # Handle agentic tracers
-        logger.debug(f"Starting Instrumentation for tracer type: {tracer_type}")
         if tracer_type == "agentic" or tracer_type.startswith("agentic/") or tracer_type == "langchain":
             # Setup instrumentors based on tracer type
             instrumentors = []
 
             # Add LLM Instrumentors
             if tracer_type in ['agentic/crewai']:
-                logger.debug("Setting up instrumentors for CrewAI")
                 try:
                     from openinference.instrumentation.vertexai import VertexAIInstrumentor
                     instrumentors.append((VertexAIInstrumentor, []))
@@ -325,38 +310,31 @@ class Tracer(AgenticTracing):
             elif tracer_type == "agentic/llamaindex" or tracer_type == "llamaindex":
                 from openinference.instrumentation.llama_index import LlamaIndexInstrumentor
                 instrumentors += [(LlamaIndexInstrumentor, [])] 
-                logger.info("Instrumenting LlamaIndex...")
 
             elif tracer_type == "agentic/langchain" or tracer_type == "agentic/langgraph" or tracer_type == "langchain":
                 from openinference.instrumentation.langchain import LangChainInstrumentor
                 instrumentors += [(LangChainInstrumentor, [])]
-                logger.info("Instrumenting LangChain...")
             
             elif tracer_type == "agentic/crewai":
                 from openinference.instrumentation.crewai import CrewAIInstrumentor
                 from openinference.instrumentation.langchain import LangChainInstrumentor
                 instrumentors += [(CrewAIInstrumentor, []), (LangChainInstrumentor, [])]
-                logger.info("Instrumenting CrewAI...")
             
             elif tracer_type == "agentic/haystack":
                 from openinference.instrumentation.haystack import HaystackInstrumentor
                 instrumentors += [(HaystackInstrumentor, [])]
-                logger.info("Instrumenting Haystack...")
             
             elif tracer_type == "agentic/autogen":
                 from openinference.instrumentation.autogen import AutogenInstrumentor
                 instrumentors += [(AutogenInstrumentor, [])]
-                logger.info("Instrumenting Autogen...")
             
             elif tracer_type == "agentic/smolagents":
                 from openinference.instrumentation.smolagents import SmolagentsInstrumentor
                 instrumentors += [(SmolagentsInstrumentor, [])]
-                logger.info("Instrumenting Smolagents...")
 
             elif tracer_type == "agentic/openai_agents":
                 from openinference.instrumentation.openai_agents import OpenAIAgentsInstrumentor
                 instrumentors += [(OpenAIAgentsInstrumentor, [])] 
-                logger.info("Instrumenting OpenAI Agents...")
             
             else:
                 # Unknown agentic tracer type

{ragaai_catalyst-2.2.4.1b4.dist-info → ragaai_catalyst-2.2.4.1b5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ragaai_catalyst
-Version: 2.2.4.1b4
+Version: 2.2.4.1b5
 Summary: RAGA AI CATALYST
 Author-email: Kiran Scaria <kiran.scaria@raga.ai>, Kedar Gaikwad <kedar.gaikwad@raga.ai>, Dushyant Mahajan <dushyant.mahajan@raga.ai>, Siddhartha Kosti <siddhartha.kosti@raga.ai>, Ritika Goel <ritika.goel@raga.ai>, Vijay Chaurasia <vijay.chaurasia@raga.ai>, Tushar Kumar <tushar.kumar@raga.ai>, Rishabh Pandey <rishabh.pandey@raga.ai>, Jyotsana C G <jyotsana@raga.ai>
 Requires-Python: <=3.13.2,>=3.10

{ragaai_catalyst-2.2.4.1b4.dist-info → ragaai_catalyst-2.2.4.1b5.dist-info}/RECORD

@@ -31,7 +31,7 @@ ragaai_catalyst/tracers/distributed.py,sha256=CGPuOh4CsgEk428PPibieLaAG2Tt3BVygF
 ragaai_catalyst/tracers/langchain_callback.py,sha256=CB75zzG3-DkYTELj0vI1MOHQTY0MuQJfoHIXz9Cl8S8,34568
 ragaai_catalyst/tracers/llamaindex_callback.py,sha256=ZY0BJrrlz-P9Mg2dX-ZkVKG3gSvzwqBtk7JL_05MiYA,14028
 ragaai_catalyst/tracers/llamaindex_instrumentation.py,sha256=Ys_jLkvVqo12bKgXDmkp4TxJu9HkBATrFE8cIcTYxWw,14329
-ragaai_catalyst/tracers/tracer.py,sha256=2JmeM9OkxNyS6XG0Ogqhx8q9lvy3vNLJnEVH2Vg2RNM,42768
+ragaai_catalyst/tracers/tracer.py,sha256=hxVJN45CtIeU8Dc5G1kreXJa7Vv_3buBAHVz-Q3buKo,41435
 ragaai_catalyst/tracers/upload_traces.py,sha256=w1clGGfdOMpStUJX40NAlxe6dcFdN4pwcezyII0bGYA,6994
 ragaai_catalyst/tracers/agentic_tracing/README.md,sha256=X4QwLb7-Jg7GQMIXj-SerZIgDETfw-7VgYlczOR8ZeQ,4508
 ragaai_catalyst/tracers/agentic_tracing/__init__.py,sha256=yf6SKvOPSpH-9LiKaoLKXwqj5sez8F_5wkOb91yp0oE,260
@@ -54,9 +54,10 @@ ragaai_catalyst/tracers/agentic_tracing/tracers/network_tracer.py,sha256=m8CxYkl
 ragaai_catalyst/tracers/agentic_tracing/tracers/tool_tracer.py,sha256=xxrliKPfdfbIZRZqMnUewsaTD8_Hv0dbuoBivNZGD4U,21674
 ragaai_catalyst/tracers/agentic_tracing/tracers/user_interaction_tracer.py,sha256=bhSUhNQCuJXKjgJAXhjKEYjnHMpYN90FSZdR84fNIKU,4614
 ragaai_catalyst/tracers/agentic_tracing/upload/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-ragaai_catalyst/tracers/agentic_tracing/upload/trace_uploader.py,sha256=iMUMFR9XVipCBunpv8_No8bCoP3lqG47M5dg-ugibWo,21006
-ragaai_catalyst/tracers/agentic_tracing/upload/upload_agentic_traces.py,sha256=KOtnB-QFpVFD0zKpJ2epOq8r0tSdFPRKe0rTA53A5Zo,12738
-ragaai_catalyst/tracers/agentic_tracing/upload/upload_code.py,sha256=2mxdi7k_SoDqQUFo1oQ__28CpmSIvVugYcbuRltUK9Q,9920
+ragaai_catalyst/tracers/agentic_tracing/upload/session_manager.py,sha256=xgheT_XV2PFov709V0J5DwytW9-muvZnPTjbMsurGAw,5335
+ragaai_catalyst/tracers/agentic_tracing/upload/trace_uploader.py,sha256=Ujbu0KDl7oDr-cFtLwrQK_i7ghMuPV92mFnRfobJ1aI,24822
+ragaai_catalyst/tracers/agentic_tracing/upload/upload_agentic_traces.py,sha256=vH9at3012iNrNIA30TMr7qLyvWtKyZn9wpd5esmBg0A,12866
+ragaai_catalyst/tracers/agentic_tracing/upload/upload_code.py,sha256=bpzL-eNCUaqXimSg7nl5YB0KlHbS_2sNvJTfKnfRjek,12027
 ragaai_catalyst/tracers/agentic_tracing/upload/upload_local_metric.py,sha256=m1O8lKpxKwtHofXLW3fTHX5yfqDW5GxoveARlg5cTw4,2571
 ragaai_catalyst/tracers/agentic_tracing/utils/__init__.py,sha256=XdB3X_ufe4RVvGorxSqAiB9dYv4UD7Hvvuw3bsDUppY,60
 ragaai_catalyst/tracers/agentic_tracing/utils/api_utils.py,sha256=ZduFA7MmTnWfQ2FzSD0hxMAAfNNTgBs4CXcHZdXJv6k,749
@@ -76,7 +77,7 @@ ragaai_catalyst/tracers/exporters/__init__.py,sha256=wQbaqyeIjVZxYprHCKZ9BeiqxeX
 ragaai_catalyst/tracers/exporters/dynamic_trace_exporter.py,sha256=Rm-QaLv1qMAKpHKcFOcK_HWaKHwFBoUH45_4QYipE-g,6843
 ragaai_catalyst/tracers/exporters/file_span_exporter.py,sha256=NZsD3rShUiC3rO9y3Y2vqEtS3MO51FXZy0p3q9cdDNY,6403
 ragaai_catalyst/tracers/exporters/raga_exporter.py,sha256=l-RfysTIXYxtvYkVlJbRvg-AzJbT4Fdb-YiZh0mfuDs,17868
-ragaai_catalyst/tracers/exporters/ragaai_trace_exporter.py,sha256=UNoXvMTJ2PArlcNWBk424WLQt7i5BZGGwztFo18iqlc,10800
+ragaai_catalyst/tracers/exporters/ragaai_trace_exporter.py,sha256=VxO96ldBpG5mCncrN5mXErIZMlxQ1ewhNoMLfCrzegM,9025
 ragaai_catalyst/tracers/instrumentators/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 ragaai_catalyst/tracers/utils/__init__.py,sha256=KeMaZtYaTojilpLv65qH08QmpYclfpacDA0U3wg6Ybw,64
 ragaai_catalyst/tracers/utils/convert_langchain_callbacks_output.py,sha256=SehrD7q8ytAiUYoWr406b4mWs3Lk0Rcy6Ekkihh22TI,1703
@@ -88,8 +89,8 @@ ragaai_catalyst/tracers/utils/rag_extraction_logic_final.py,sha256=3ygkRT__lLDRf
 ragaai_catalyst/tracers/utils/rag_trace_json_converter.py,sha256=54IEZO-YRjUAahV5nw8KClXqTF1LhfDry_TsZ4KGow4,20467
 ragaai_catalyst/tracers/utils/trace_json_converter.py,sha256=-HZVmijeUFLO7e9OAvi1RJdWVTxPRUHPd1MkKQlCD54,11785
 ragaai_catalyst/tracers/utils/utils.py,sha256=o-p9n2ZuophdrV0wrixu-BqRHCkovup_klc3mS8mU8g,2374
-ragaai_catalyst-2.2.4.1b4.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-ragaai_catalyst-2.2.4.1b4.dist-info/METADATA,sha256=TOTjSMMYeaIMLvUPryfxf5AjEmbox9aTJapUJEUEFtQ,17681
-ragaai_catalyst-2.2.4.1b4.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-ragaai_catalyst-2.2.4.1b4.dist-info/top_level.txt,sha256=HpgsdRgEJMk8nqrU6qdCYk3di7MJkDL0B19lkc7dLfM,16
-ragaai_catalyst-2.2.4.1b4.dist-info/RECORD,,
+ragaai_catalyst-2.2.4.1b5.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+ragaai_catalyst-2.2.4.1b5.dist-info/METADATA,sha256=aZAvm_cDpbl_xbOO6d9Lp2kMLmRmdiViDe6EIWDufaI,17681
+ragaai_catalyst-2.2.4.1b5.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+ragaai_catalyst-2.2.4.1b5.dist-info/top_level.txt,sha256=HpgsdRgEJMk8nqrU6qdCYk3di7MJkDL0B19lkc7dLfM,16
+ragaai_catalyst-2.2.4.1b5.dist-info/RECORD,,