ragaai-catalyst 2.2.4.1b1__tar.gz → 2.2.4.1b3__tar.gz

{ragaai_catalyst-2.2.4.1b1/ragaai_catalyst.egg-info → ragaai_catalyst-2.2.4.1b3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ragaai_catalyst
-Version: 2.2.4.1b1
+Version: 2.2.4.1b3
 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.1b1 → ragaai_catalyst-2.2.4.1b3}/pyproject.toml

@@ -8,7 +8,7 @@ description = "RAGA AI CATALYST"
 readme = "README.md"
 requires-python = ">=3.10,<=3.13.2"
 # license = {file = "LICENSE"}
-version = "2.2.4.1.beta.1"
+version = "2.2.4.1.beta.3"
 authors = [
     {name = "Kiran Scaria", email = "kiran.scaria@raga.ai"},
     {name = "Kedar Gaikwad", email = "kedar.gaikwad@raga.ai"},

{ragaai_catalyst-2.2.4.1b1 → ragaai_catalyst-2.2.4.1b3}/ragaai_catalyst/tracers/agentic_tracing/upload/trace_uploader.py

@@ -22,7 +22,6 @@ 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)
@@ -50,13 +49,11 @@ 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")
@@ -75,10 +72,6 @@ _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
@@ -95,7 +88,7 @@ def get_executor(max_workers=None):
         if _executor is None:
             # Calculate optimal worker count
             if max_workers is None:
-                max_workers = min(8, (os.cpu_count() or 1) * 4)
+                max_workers = min(32, (os.cpu_count() or 1) * 4)
 
             logger.info(f"Creating ThreadPoolExecutor with {max_workers} workers")
             _executor = concurrent.futures.ThreadPoolExecutor(
@@ -117,57 +110,9 @@ 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, tracer_type, timeout=120, fail_on_trace_error=True) -> Dict[str, Any]:
+                  user_details: Dict[str, Any], base_url: str, timeout=120, fail_on_trace_error=True) -> Dict[str, Any]:
     """
     Process a single upload task
     
@@ -220,36 +165,20 @@ 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 (with caching)
+        # Step 1: Create dataset schema
         logger.info(f"Creating dataset schema for {dataset_name} with base_url: {base_url} and timeout: {timeout}")
-
-        # 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
+        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
             
         # Step 2: Upload trace metrics
         # if filepath and os.path.exists(filepath):
@@ -309,34 +238,28 @@ def process_upload(task_id: str, filepath: str, hash_id: str, zip_path: str,
                 logger.error(error_msg)
         
         # Step 4: Upload code hash
-        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")
-
+        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")
+        
         # 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
@@ -379,8 +302,7 @@ 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,
-                       tracer_type, timeout=120):
+def submit_upload_task(filepath, hash_id, zip_path, project_name, project_id, dataset_name, user_details, base_url, timeout=120):
     """
     Submit a new upload task using futures.
     
@@ -427,7 +349,6 @@ 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
             )
@@ -458,7 +379,6 @@ 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
         )
@@ -630,14 +550,6 @@ 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-2.2.4.1b1 → ragaai_catalyst-2.2.4.1b3}/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,36 +47,42 @@ 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 = session_manager.session.request(
+            response = requests.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 == 200:
+            if response.status_code in [200, 201]:
                 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 = session_manager.session.request(
+                response = requests.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 == 200:
+                if response.status_code in [200, 201]:
                     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.")
@@ -86,7 +92,7 @@ class UploadAgenticTraces:
                         "Authorization": f"Bearer {token}",
                         "X-Project-Name": self.project_name,
                     }
-                    response = session_manager.session.request(
+                    response = requests.request(
                         "POST",
                         endpoint,
                         headers=headers,
@@ -97,11 +103,13 @@ class UploadAgenticTraces:
                     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]:
                         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(
@@ -113,10 +121,8 @@ class UploadAgenticTraces:
                         f"Error while getting presigned url: {response.json()['message']}"
                     )
                     return None
-        except (PoolError, MaxRetryError, NewConnectionError, ConnectionError, Timeout) as e:
-            session_manager.handle_request_exceptions(e, "getting presigned URL")
-            return None
-        except RequestException as e:
+
+        except requests.exceptions.RequestException as e:
             logger.error(f"Error while getting presigned url: {e}")
             return None
 
@@ -143,16 +149,16 @@ class UploadAgenticTraces:
 
         if "blob.core.windows.net" in presignedUrl:  # Azure
             headers["x-ms-blob-type"] = "BlockBlob"
-        logger.info("Uploading agentic traces to presigned URL...")
+        print("Uploading agentic traces...")
         try:
             with open(filename) as f:
                 payload = f.read().replace("\n", "").replace("\r", "").encode()
         except Exception as e:
-            logger.error(f"Error while reading file: {e}")
+            print(f"Error while reading file: {e}")
             return False
         try:
             start_time = time.time()
-            response = session_manager.session.request(
+            response = requests.request(
                 "PUT", presignedUrl, headers=headers, data=payload, timeout=self.timeout
             )
             elapsed_ms = (time.time() - start_time) * 1000
@@ -162,11 +168,8 @@ class UploadAgenticTraces:
             if response.status_code != 200 or response.status_code != 201:
                 return response, response.status_code
             return True
-        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}")
+        except requests.exceptions.RequestException as e:
+            print(f"Error while uploading to presigned url: {e}")
             return False
 
     def insert_traces(self, presignedUrl):
@@ -182,18 +185,21 @@ 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 = session_manager.session.request(
+            response = requests.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.info(f"Traces inserted successfully: {response.json()['message']}")
+                logger.debug("Successfully inserted traces")
                 return True
             elif response.status_code == 401:
                 logger.warning("Received 401 error. Attempting to refresh token.")
@@ -203,7 +209,7 @@ class UploadAgenticTraces:
                     "Content-Type": "application/json",
                     "X-Project-Name": self.project_name,
                 }
-                response = session_manager.session.request(
+                response = requests.request(
                     "POST",
                     endpoint,
                     headers=headers,
@@ -215,27 +221,24 @@ class UploadAgenticTraces:
                     f"API Call: [POST] {endpoint} | Status: {response.status_code} | Time: {elapsed_ms:.2f}ms"
                 )
                 if response.status_code in [200, 201]:
-                    logger.info(f"Traces inserted successfully: {response.json()['message']}")
+                    logger.debug("Successfully inserted traces")
                     return True
                 else:
-                    logger.error(f"Error while inserting traces after 401: {response.json()['message']}")
+                    logger.debug("Error while inserting traces")
                     return False
             else:
-                logger.error(f"Error while inserting traces: {response.json()['message']}")
+                logger.debug("Error while inserting traces")
                 return False
-        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
+        except requests.exceptions.RequestException as e:
+            logger.debug(f"Error while inserting traces: {e}")
+            return None
 
     def _get_dataset_spans(self):
         try:
             with open(self.json_file_path) as f:
                 data = json.load(f)
         except Exception as e:
-            print(f"Error while reading file: {e}")
+            logger.debug(f"Error while reading file: {e}")
             return None
         try:
             spans = data["data"][0]["spans"]
@@ -257,41 +260,41 @@ class UploadAgenticTraces:
                     continue
             return dataset_spans
         except Exception as e:
-            logger.error(f"Error while reading dataset spans: {e}")
+            logger.debug(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.warning("Warning: Failed to obtain presigned URL")
+                logger.debug("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.error("Error: Failed to upload file to presigned URL")
+                logger.debug("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.error(
-                        f"Error: Uploading agentic traces failed with status code {status_code}: {response.text if hasattr(response, 'text') else 'Unknown error'}")
+                    logger.debug(
+                        f"Error: Upload 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:
-                print("Error: Failed to insert trace records")
+                logger.debug("Error: Failed to insert trace records")
                 return False
 
-            logger.info("Successfully uploaded agentic traces")
+            logger.debug("Successfully uploaded agentic traces")
             return True
         except FileNotFoundError:
-            logger.error(f"Error: Trace file not found at {self.json_file_path}")
+            logger.debug(f"Error: Trace file not found at {self.json_file_path}")
             return False
         except ConnectionError as e:
-            logger.error(f"Error: Network connection failed while uploading traces: {e}")
+            logger.debug(f"Error: Network connection failed while uploading traces: {e}")
             return False
         except Exception as e:
-            logger.error(f"Error while uploading agentic traces: {e}")
+            logger.debug(f"Error while uploading agentic traces: {e}")
             return False