ragaai-catalyst 2.2.5b3__tar.gz → 2.2.5b4__tar.gz

{ragaai_catalyst-2.2.5b3 → ragaai_catalyst-2.2.5b4}/.gitignore

@@ -166,69 +166,4 @@ cython_debug/
 #  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
 #  and can be added to the global gitignore or merged into this file.  For a more nuclear
 #  option (not recommended) you can uncomment the following to ignore the entire idea folder.
-#.idea/
-
-
-agent_load_test_exceptions.csv
-agent_load_test_failures.csv
-agent_load_test_stats.csv
-agent_load_test_stats_history.csv
-ai_document_061023_2.pdf
-catalyst_v2.ipynb
-chroma_db/
-custom_cost_bug.ipynb
-custom_cost_bug.py
-deephealth_sample_50_data.csv
-dh_full_test.ipynb
-diagnosis_agent.py
-langchain_sample_trace.json
-legal_rag.py
-load_test_streaming.py
-load_test_v1.py
-load_test_v2.py
-# locustfile.py
-masking_example.py
-model_prices_and_context_window_backup.json
-# multi_llm_test.py
-rag_agent_traces.json
-rag_agent_traces_with_streaming.json
-rag_agent_traces_wo_streaming.json
-rag_extraction_logic_final.py
-research_assistant.py
-sci_fi_story.md
-scifi_writer.py
-stress_test_langchain.py
-test.ipynb
-test_token_refresh.py
-uplaod_numerical_col_csv.py
-dh_full_test.py
-model_gemini_15_flash_002_w_stream.json
-model_gemini_15_flash_002_wo_stream.json
-model_gpt_4o_mini_w_stream.json
-model_gpt_4o_mini_wo_stream.json
-model_gpt_41_w_stream.json
-model_gpt_41_wo_stream.json
-RAG_LOAD_TEST_README.md
-locustfile.py
-locustfile_fixed.py
-locustfile_rag.py
-multi_llm_test.py
-run_rag_load_test.py
-set_dataset_name_test.py
-simple_rag_app.py
-trace_upload_analysis.md
-updated_pydantic_test.py
-langchain_rag.py
-pydantic_test.ipynb
-test_2.py
-docker_gt_dataset1.csv
-direct_anthropic.json
-direct_llm_call_test.py
-direct_llm_examples.py
-direct_opanai.json
-new_feature_test.ipynb
-ex_google_adk.py
-multi_tool_agent/
-storyflow_agent.py
-google_adk_agent_ex.py
-Quickstart.md
+#.idea/

{ragaai_catalyst-2.2.5b3/ragaai_catalyst.egg-info → ragaai_catalyst-2.2.5b4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ragaai_catalyst
-Version: 2.2.5b3
+Version: 2.2.5b4
 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.5b3 → ragaai_catalyst-2.2.5b4}/Quickstart.md

@@ -1,4 +1,4 @@
-# Quickstart
+# Quickstart | RagaAI Catalyst
 
 ## **1. Install RagaAI Catalyst**
 
@@ -17,8 +17,6 @@ pip install ragaai-catalyst
 2. Navigate to **Profile Settings** → **Authentication**.
 3. Click **Generate New Key** to obtain your **Access Key** and **Secret Key**.
 
-![How to generate authentication keys](docs/img/autheticate.gif)
-
 ### **Initialize the SDK**
 
 To begin using Catalyst, initialize it as follows:
@@ -33,6 +31,7 @@ catalyst = RagaAICatalyst(
 )
 ```
 
+
 ## **3. Create Your First Project**
 
 Create a new project and choose a use case from the available options:
@@ -47,8 +46,6 @@ project = catalyst.create_project(
 # List available use cases
 print(catalyst.project_use_cases())
 ```
-![Projects](docs/img/create_project.gif)
-
 
 ### **Add a Dataset**
 Initialize the dataset manager and create a dataset from a CSV file, DataFrame, or JSONl file.
@@ -74,7 +71,7 @@ dataset_manager.create_from_csv(
 # View dataset schema
 print(dataset_manager.get_schema_mapping())
 ```
-![Dataset](docs/img/dataset.gif)
+
 
 ## **4. Trace Your Application**
 
@@ -147,7 +144,7 @@ tracer.stop()
 # Verify data capture
 print(tracer.get_upload_status())
 ```
-![Tracing](docs/img/last_main.png)
+
 
 
 ## **5. Evaluation Framework**
@@ -192,4 +189,12 @@ evaluation.add_metrics(
 print(f"Status: {evaluation.get_status()}")
 print(f"Results: {evaluation.get_results()}")
 ```
-![Evaluation](docs/img/evaluation.gif)
+
+
+
+## **Next Steps**
+- **Explore the Dashboard:** Visualize metrics and insights in the RagaAI Web UI.
+
+
+
+**Version:** 1.0.0 | **Last Updated:** Mar 2025

{ragaai_catalyst-2.2.5b3 → ragaai_catalyst-2.2.5b4}/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.5.beta.3"
+version = "2.2.5.beta.4"
 authors = [
     {name = "Kiran Scaria", email = "kiran.scaria@raga.ai"},
     {name = "Kedar Gaikwad", email = "kedar.gaikwad@raga.ai"},

ragaai_catalyst-2.2.5b4/ragaai_catalyst/tracers/agentic_tracing/upload/session_manager.py

@@ -0,0 +1,156 @@
+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 http.client import RemoteDisconnected
+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
+            connect=3,  # number of retries for connection-related errors
+            read=3,  # number of retries for read-related errors
+            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)
+
+        # Set session-level configuration to handle connection issues
+        self._session.headers.update({
+            'Connection': 'keep-alive',
+            'User-Agent': 'RagaAI-Catalyst/1.0'
+        })
+
+        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 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=10)
+                logger.info(f"Warmup connection {i+1}: Status {response.status_code}")
+            except Exception as e:
+                logger.warning(f"Warmup connection {i+1} failed (this may be normal): {e}")
+                # Ignore other 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, RemoteDisconnected):
+            logger.error(f"Remote connection closed unexpectedly 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}")
+
+    def make_request_with_retry(self, method, url, **kwargs):
+        """
+        Make HTTP request with additional retry logic for RemoteDisconnected errors
+        that may not be caught by urllib3's retry mechanism.
+        """
+        max_retries = 3
+        for attempt in range(max_retries):
+            try:
+                response = self._session.request(method, url, **kwargs)
+                return response
+            except (RemoteDisconnected, ConnectionError) as e:
+                logger.warning(f"Connection error on attempt {attempt + 1}/{max_retries}: {e}")
+                if attempt == max_retries - 1:
+                    # Re-raise the exception on the last attempt
+                    raise
+                # Wait before retrying (exponential backoff)
+                import time
+                wait_time = 2 ** attempt
+                logger.info(f"Retrying in {wait_time} seconds...")
+                time.sleep(wait_time)
+
+
+# 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-2.2.5b3 → ragaai_catalyst-2.2.5b4}/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)