ragaai-catalyst 2.1.5b1__py3-none-any.whl → 2.1.5b2__py3-none-any.whl

ragaai_catalyst/dataset.py

@@ -434,17 +434,16 @@ class Dataset:
             
             # Check response
             response_data = response.json()
-            if not response_data.get('success', False):
-                raise ValueError(response_data.get('message', 'Unknown error occurred'))
-            
-            print(f"Successfully added rows to dataset {dataset_name}")
-            return response_data
+            if response_data.get('success', False):
+                print(f"{response_data['message']}")
+            else:
+                raise ValueError(response_data.get('message', 'Failed to add rows'))
         
         except Exception as e:
             logger.error(f"Error in add_rows_to_dataset: {e}")
             raise
 
-    def add_columns(self,text_fields,dataset_name, column_name, provider, model,variables={}):
+    def add_columns(self, text_fields, dataset_name, column_name, provider, model, variables={}):
         """
         Add a column to a dataset with dynamically fetched model parameters
         
@@ -571,7 +570,7 @@ class Dataset:
                     variable_specs.append({
                         "name": key,
                         "type": "string",
-                        "schema": values
+                        "schema": "query"
                     })
                 add_column_payload["promptTemplate"]["variableSpecs"] = variable_specs
             
@@ -593,9 +592,10 @@ class Dataset:
             response.raise_for_status()
             response_data = response.json()
             
-            print("Column added successfully:")
-            print(json.dumps(response_data, indent=2))
-            return response_data
+            if response_data.get('success', False):
+                print(f"Column '{column_name}' added successfully to dataset '{dataset_name}'")
+            else:
+                raise ValueError(response_data.get('message', 'Failed to add column'))
         
         except requests.exceptions.RequestException as e:
             print(f"Error adding column: {e}")

ragaai_catalyst/tracers/agentic_tracing/tracers/base.py

@@ -1,8 +1,5 @@
 import json
 import os
-import platform
-import psutil
-import pkg_resources
 from datetime import datetime
 from pathlib import Path
 from typing import List, Any, Dict
@@ -16,20 +13,9 @@ from ..data.data_structure import (
     Trace,
     Metadata,
     SystemInfo,
-    OSInfo,
-    EnvironmentInfo,
     Resources,
-    CPUResource,
-    MemoryResource,
-    DiskResource,
-    NetworkResource,
-    ResourceInfo,
-    MemoryInfo,
-    DiskInfo,
-    NetworkInfo,
     Component,
 )
-
 from ..upload.upload_agentic_traces import UploadAgenticTraces
 from ..upload.upload_code import upload_code
 from ..upload.upload_trace_metric import upload_trace_metric
@@ -37,9 +23,8 @@ from ..utils.file_name_tracker import TrackName
 from ..utils.zip_list_of_unique_files import zip_list_of_unique_files
 from ..utils.span_attributes import SpanAttributes
 from ..utils.create_dataset_schema import create_dataset_schema_with_trace
+from ..utils.system_monitor import SystemMonitor
 
-
-# Configure logging to show debug messages (which includes info messages as well)
 import logging
 
 logger = logging.getLogger(__name__)
@@ -76,12 +61,12 @@ class TracerJSONEncoder(json.JSONEncoder):
 class BaseTracer:
     def __init__(self, user_details):
         self.user_details = user_details
-        self.project_name = self.user_details["project_name"]  # Access the project_name
-        self.dataset_name = self.user_details["dataset_name"]  # Access the dataset_name
-        self.project_id = self.user_details["project_id"]  # Access the project_id
-        self.trace_name = self.user_details["trace_name"]  # Access the trace_name
+        self.project_name = self.user_details["project_name"]
+        self.dataset_name = self.user_details["dataset_name"]
+        self.project_id = self.user_details["project_id"]
+        self.trace_name = self.user_details["trace_name"]
         self.visited_metrics = []
-        self.trace_metrics = []  # Store metrics here
+        self.trace_metrics = []
 
         # Initialize trace data
         self.trace_id = None
@@ -97,117 +82,60 @@ class BaseTracer:
         self.network_usage_list = []
         self.tracking_thread = None
         self.tracking = False
+        self.system_monitor = None
 
     def _get_system_info(self) -> SystemInfo:
-        # Get OS info
-        os_info = OSInfo(
-            name=platform.system(),
-            version=platform.version(),
-            platform=platform.machine(),
-            kernel_version=platform.release(),
-        )
-
-        # Get Python environment info
-        installed_packages = [
-            f"{pkg.key}=={pkg.version}" for pkg in pkg_resources.working_set
-        ]
-        env_info = EnvironmentInfo(
-            name="Python",
-            version=platform.python_version(),
-            packages=installed_packages,
-            env_path=sys.prefix,
-            command_to_run=f"python {sys.argv[0]}",
-        )
-
-        return SystemInfo(
-            id=f"sys_{self.trace_id}",
-            os=os_info,
-            environment=env_info,
-            source_code="Path to the source code .zip file in format hashid.zip",  # TODO: Implement source code archiving
-        )
+        return self.system_monitor.get_system_info()
 
     def _get_resources(self) -> Resources:
-        # CPU info
-        cpu_info = ResourceInfo(
-            name=platform.processor(),
-            cores=psutil.cpu_count(logical=False),
-            threads=psutil.cpu_count(logical=True),
-        )
-        cpu = CPUResource(info=cpu_info, interval="5s", values=[psutil.cpu_percent()])
-
-        # Memory info
-        memory = psutil.virtual_memory()
-        mem_info = MemoryInfo(
-            total=memory.total / (1024**3),  # Convert to GB
-            free=memory.available / (1024**3),
-        )
-        mem = MemoryResource(info=mem_info, interval="5s", values=[memory.percent])
-
-        # Disk info
-        disk = psutil.disk_usage("/")
-        disk_info = DiskInfo(total=disk.total / (1024**3), free=disk.free / (1024**3))
-        disk_io = psutil.disk_io_counters()
-        disk_resource = DiskResource(
-            info=disk_info,
-            interval="5s",
-            read=[disk_io.read_bytes / (1024**2)],  # MB
-            write=[disk_io.write_bytes / (1024**2)],
-        )
-
-        # Network info
-        net_io = psutil.net_io_counters()
-        net_info = NetworkInfo(
-            upload_speed=net_io.bytes_sent / (1024**2),  # MB
-            download_speed=net_io.bytes_recv / (1024**2),
-        )
-        net = NetworkResource(
-            info=net_info,
-            interval="5s",
-            uploads=[net_io.bytes_sent / (1024**2)],
-            downloads=[net_io.bytes_recv / (1024**2)],
-        )
-
-        return Resources(cpu=cpu, memory=mem, disk=disk_resource, network=net)
+        return self.system_monitor.get_resources()
 
     def _track_memory_usage(self):
         self.memory_usage_list = []
         while self.tracking:
-            memory_usage = psutil.Process().memory_info().rss
-            self.memory_usage_list.append(memory_usage / (1024 * 1024))  # Convert to MB and append to the list
-            time.sleep(self.interval_time)
+            usage = self.system_monitor.track_memory_usage()
+            self.memory_usage_list.append(usage)
+            try:
+                time.sleep(self.interval_time)
+            except Exception as e:
+                logger.warning(f"Sleep interrupted in memory tracking: {str(e)}")
 
     def _track_cpu_usage(self):
         self.cpu_usage_list = []
         while self.tracking:
-            cpu_usage = psutil.cpu_percent(interval=self.interval_time)
-            self.cpu_usage_list.append(cpu_usage)
-            time.sleep(self.interval_time)
+            usage = self.system_monitor.track_cpu_usage(self.interval_time)
+            self.cpu_usage_list.append(usage)
+            try:
+                time.sleep(self.interval_time)
+            except Exception as e:
+                logger.warning(f"Sleep interrupted in CPU tracking: {str(e)}")
 
     def _track_disk_usage(self):
         self.disk_usage_list = []
         while self.tracking:
-            disk_io = psutil.disk_io_counters()
-            self.disk_usage_list.append({
-                'disk_read': disk_io.read_bytes / (1024 * 1024),  # Convert to MB
-                'disk_write': disk_io.write_bytes / (1024 * 1024)  # Convert to MB
-            })
-            time.sleep(self.interval_time)
+            usage = self.system_monitor.track_disk_usage()
+            self.disk_usage_list.append(usage)
+            try:
+                time.sleep(self.interval_time)
+            except Exception as e:
+                logger.warning(f"Sleep interrupted in disk tracking: {str(e)}")
 
     def _track_network_usage(self):
         self.network_usage_list = []
         while self.tracking:
-            net_io = psutil.net_io_counters()
-            self.network_usage_list.append({
-                'uploads': net_io.bytes_sent / (1024 * 1024),  # Convert to MB
-                'downloads': net_io.bytes_recv / (1024 * 1024)  # Convert to MB
-            })
-            time.sleep(self.interval_time)
+            usage = self.system_monitor.track_network_usage()
+            self.network_usage_list.append(usage)
+            try:
+                time.sleep(self.interval_time)
+            except Exception as e:
+                logger.warning(f"Sleep interrupted in network tracking: {str(e)}")
 
     def start(self):
         """Initialize a new trace"""
         self.tracking = True
-        self.tracking_thread = threading.Thread(target=self._track_memory_usage)
-        self.tracking_thread.start()
+        self.trace_id = str(uuid.uuid4())
+        self.system_monitor = SystemMonitor(self.trace_id)
+        threading.Thread(target=self._track_memory_usage).start()
         threading.Thread(target=self._track_cpu_usage).start()
         threading.Thread(target=self._track_disk_usage).start()
         threading.Thread(target=self._track_network_usage).start()
@@ -223,9 +151,6 @@ class BaseTracer:
             resources=self._get_resources(),
         )
 
-        # Generate a unique trace ID, when trace starts
-        self.trace_id = str(uuid.uuid4())
-
         # Get the start time
         self.start_time = datetime.now().astimezone().isoformat()
 
@@ -257,8 +182,6 @@ class BaseTracer:
 
             #track memory usage
             self.tracking = False
-            if self.tracking_thread is not None:
-                self.tracking_thread.join()
             self.trace.metadata.resources.memory.values = self.memory_usage_list
 
             #track cpu usage
@@ -695,12 +618,11 @@ class BaseTracer:
         # Process additional interactions and network calls
         if "interactions" in child:
             for interaction in child["interactions"]:
-                if interaction!=[]:
-                    interaction["id"] = str(interaction_id)
-                    interaction["span_id"] = child.get("id")
-                    interaction["error"] = None
-                    interactions.append(interaction)
-                    interaction_id += 1
+                interaction["id"] = str(interaction_id)
+                interaction["span_id"] = child.get("id")
+                interaction["error"] = None
+                interactions.append(interaction)
+                interaction_id += 1
 
         if "network_calls" in child:
             for child_network_call in child["network_calls"]:
@@ -877,16 +799,15 @@ class BaseTracer:
             # Process interactions from span.data if they exist
             if span.interactions:
                 for span_interaction in span.interactions:
-                    if span_interaction != []:
-                        interaction = {}
-                        interaction["id"] = str(interaction_id)
-                        interaction["span_id"] = span.id
-                        interaction["interaction_type"] = span_interaction.type
-                        interaction["content"] = span_interaction.content
-                        interaction["timestamp"] = span_interaction.timestamp
-                        interaction["error"] = span.error
-                        interactions.append(interaction)
-                        interaction_id += 1
+                    interaction = {}
+                    interaction["id"] = str(interaction_id)
+                    interaction["span_id"] = span.id
+                    interaction["interaction_type"] = span_interaction.type
+                    interaction["content"] = span_interaction.content
+                    interaction["timestamp"] = span_interaction.timestamp
+                    interaction["error"] = span.error
+                    interactions.append(interaction)
+                    interaction_id += 1
 
             if span.network_calls:
                 for span_network_call in span.network_calls:

ragaai_catalyst/tracers/agentic_tracing/tracers/llm_tracer.py

@@ -78,6 +78,7 @@ class LLMTracerMixin:
 
         if "openai" in sys.modules:
             self.patch_openai_methods(sys.modules["openai"])
+            self.patch_openai_beta_methods(sys.modules["openai"])
         if "litellm" in sys.modules:
             self.patch_litellm_methods(sys.modules["litellm"])
         if "anthropic" in sys.modules:
@@ -97,6 +98,7 @@ class LLMTracerMixin:
             self.patch_vertex_ai_methods, "vertexai.generative_models"
         )
         wrapt.register_post_import_hook(self.patch_openai_methods, "openai")
+        wrapt.register_post_import_hook(self.patch_openai_beta_methods, "openai")
         wrapt.register_post_import_hook(self.patch_litellm_methods, "litellm")
         wrapt.register_post_import_hook(self.patch_anthropic_methods, "anthropic")
         wrapt.register_post_import_hook(
@@ -135,6 +137,40 @@ class LLMTracerMixin:
             # Log the error but continue execution
             print(f"Warning: Failed to patch OpenAI methods: {str(e)}")
 
+    def patch_openai_beta_methods(self, openai_module):
+        """
+        Patch the new openai.beta endpoints (threads, runs, messages, etc.)
+        so that calls like openai.beta.threads.create(...) or
+        openai.beta.threads.runs.create(...) are automatically traced.
+        """
+        # Make sure openai_module has a 'beta' attribute
+        if not hasattr(openai_module, "beta"):
+            return
+
+        beta_module = openai_module.beta
+
+        # Patch openai.beta.threads
+        if hasattr(beta_module, "threads"):
+            threads_obj = beta_module.threads
+            # Patch top-level methods on openai.beta.threads
+            for method_name in ["create", "list"]:
+                if hasattr(threads_obj, method_name):
+                    self.wrap_method(threads_obj, method_name)
+
+            # Patch the nested objects: messages, runs
+            if hasattr(threads_obj, "messages"):
+                messages_obj = threads_obj.messages
+                for method_name in ["create", "list"]:
+                    if hasattr(messages_obj, method_name):
+                        self.wrap_method(messages_obj, method_name)
+
+            if hasattr(threads_obj, "runs"):
+                runs_obj = threads_obj.runs
+                for method_name in ["create", "retrieve", "list"]:
+                    if hasattr(runs_obj, method_name):
+                        self.wrap_method(runs_obj, method_name)
+
+
     def patch_anthropic_methods(self, module):
         if hasattr(module, "Anthropic"):
             client_class = getattr(module, "Anthropic")

ragaai_catalyst/tracers/agentic_tracing/utils/system_monitor.py

@@ -0,0 +1,215 @@
+import platform
+import psutil
+import sys
+import pkg_resources
+import logging
+from typing import Dict, List, Optional
+from ..data.data_structure import (
+    SystemInfo,
+    OSInfo,
+    EnvironmentInfo,
+    Resources,
+    CPUResource,
+    MemoryResource,
+    DiskResource,
+    NetworkResource,
+    ResourceInfo,
+    MemoryInfo,
+    DiskInfo,
+    NetworkInfo,
+)
+
+logger = logging.getLogger(__name__)
+
+class SystemMonitor:
+    def __init__(self, trace_id: str):
+        self.trace_id = trace_id
+
+    def get_system_info(self) -> SystemInfo:
+        # Initialize with None values
+        os_info = OSInfo(
+            name=None,
+            version=None,
+            platform=None,
+            kernel_version=None,
+        )
+        env_info = EnvironmentInfo(
+            name=None,
+            version=None,
+            packages=[],
+            env_path=None,
+            command_to_run=None,
+        )
+
+        try:
+            # Get OS info
+            os_info = OSInfo(
+                name=platform.system(),
+                version=platform.version(),
+                platform=platform.machine(),
+                kernel_version=platform.release(),
+            )
+        except Exception as e:
+            logger.warning(f"Failed to get OS info: {str(e)}")
+             
+        try:
+            # Get Python environment info
+            installed_packages = [
+                f"{pkg.key}=={pkg.version}" for pkg in pkg_resources.working_set
+            ]
+            env_info = EnvironmentInfo(
+                name="Python",
+                version=platform.python_version(),
+                packages=installed_packages,
+                env_path=sys.prefix,
+                command_to_run=f"python {sys.argv[0]}",
+            )
+        except Exception as e:
+            logger.warning(f"Failed to get environment info: {str(e)}")
+             
+
+        # Always return a valid SystemInfo object
+        return SystemInfo(
+            id=f"sys_{self.trace_id}",
+            os=os_info,
+            environment=env_info,
+            source_code="",
+        )
+
+    def get_resources(self) -> Resources:
+        # Initialize with None values
+        cpu_info = ResourceInfo(
+            name=None,
+            cores=None,
+            threads=None,
+        )
+        cpu = CPUResource(info=cpu_info, interval="5s", values=[])
+
+        mem_info = MemoryInfo(
+            total=None,
+            free=None,
+        )
+        mem = MemoryResource(info=mem_info, interval="5s", values=[])
+
+        disk_info = DiskInfo(
+            total=None,
+            free=None,
+        )
+        disk_resource = DiskResource(
+            info=disk_info,
+            interval="5s",
+            read=[],
+            write=[],
+        )
+
+        net_info = NetworkInfo(
+            upload_speed=None,
+            download_speed=None,
+        )
+        net = NetworkResource(
+            info=net_info,
+            interval="5s",
+            uploads=[],
+            downloads=[],
+        )
+
+        try:
+            # CPU info
+            cpu_info = ResourceInfo(
+                name=platform.processor(),
+                cores=psutil.cpu_count(logical=False),
+                threads=psutil.cpu_count(logical=True),
+            )
+            cpu = CPUResource(info=cpu_info, interval="5s", values=[psutil.cpu_percent()])
+        except Exception as e:
+            logger.warning(f"Failed to get CPU info: {str(e)}")
+             
+
+        try:
+            # Memory info
+            memory = psutil.virtual_memory()
+            mem_info = MemoryInfo(
+                total=memory.total / (1024**3),  # Convert to GB
+                free=memory.available / (1024**3),
+            )
+            mem = MemoryResource(info=mem_info, interval="5s", values=[memory.percent])
+        except Exception as e:
+            logger.warning(f"Failed to get memory info: {str(e)}")
+             
+
+        try:
+            # Disk info
+            disk = psutil.disk_usage("/")
+            disk_info = DiskInfo(total=disk.total / (1024**3), free=disk.free / (1024**3))
+            disk_io = psutil.disk_io_counters()
+            disk_resource = DiskResource(
+                info=disk_info,
+                interval="5s",
+                read=[disk_io.read_bytes / (1024**2)],  # MB
+                write=[disk_io.write_bytes / (1024**2)],
+            )
+        except Exception as e:
+            logger.warning(f"Failed to get disk info: {str(e)}")
+             
+        try:
+            # Network info
+            net_io = psutil.net_io_counters()
+            net_info = NetworkInfo(
+                upload_speed=net_io.bytes_sent / (1024**2),  # MB
+                download_speed=net_io.bytes_recv / (1024**2),
+            )
+            net = NetworkResource(
+                info=net_info,
+                interval="5s",
+                uploads=[net_io.bytes_sent / (1024**2)],
+                downloads=[net_io.bytes_recv / (1024**2)],
+            )
+        except Exception as e:
+            logger.warning(f"Failed to get network info: {str(e)}")
+            
+
+        # Always return a valid Resources object
+        return Resources(cpu=cpu, memory=mem, disk=disk_resource, network=net)
+
+    def track_memory_usage(self) -> Optional[float]:
+        """Track memory usage in MB"""
+        try:
+            memory_usage = psutil.Process().memory_info().rss
+            return memory_usage / (1024 * 1024)  # Convert to MB
+        except Exception as e:
+            logger.warning(f"Failed to track memory usage: {str(e)}")
+            return None  
+
+    def track_cpu_usage(self, interval: float) -> Optional[float]:
+        """Track CPU usage percentage"""
+        try:
+            return psutil.cpu_percent(interval=interval)
+        except Exception as e:
+            logger.warning(f"Failed to track CPU usage: {str(e)}")
+            return None  
+
+    def track_disk_usage(self) -> Dict[str, Optional[float]]:
+        """Track disk I/O in MB"""
+        default_response = {'disk_read': None, 'disk_write': None}
+        try:
+            disk_io = psutil.disk_io_counters()
+            return {
+                'disk_read': disk_io.read_bytes / (1024 * 1024),  # Convert to MB
+                'disk_write': disk_io.write_bytes / (1024 * 1024)  # Convert to MB
+            }
+        except Exception as e:
+            logger.warning(f"Failed to track disk usage: {str(e)}")
+            return default_response 
+
+    def track_network_usage(self) -> Dict[str, Optional[float]]:
+        """Track network I/O in MB"""
+        default_response = {'uploads': None, 'downloads': None}
+        try:
+            net_io = psutil.net_io_counters()
+            return {
+                'uploads': net_io.bytes_sent / (1024 * 1024),  # Convert to MB
+                'downloads': net_io.bytes_recv / (1024 * 1024)  # Convert to MB
+            }
+        except Exception as e:
+            logger.warning(f"Failed to track network usage: {str(e)}")
+            return default_response 

{ragaai_catalyst-2.1.5b1.dist-info → ragaai_catalyst-2.1.5b2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: ragaai_catalyst
-Version: 2.1.5b1
+Version: 2.1.5b2
 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>
 Requires-Python: <3.13,>=3.9

{ragaai_catalyst-2.1.5b1.dist-info → ragaai_catalyst-2.1.5b2.dist-info}/RECORD

@@ -1,6 +1,6 @@
 ragaai_catalyst/__init__.py,sha256=tvESV8UuVtth14E89wQxgf0WvQZSApWfDeLiIdmMhkE,791
 ragaai_catalyst/_version.py,sha256=JKt9KaVNOMVeGs8ojO6LvIZr7ZkMzNN-gCcvryy4x8E,460
-ragaai_catalyst/dataset.py,sha256=Mc0L28lO4f7zD8DraQMHWzuizJf8Q0Z-DxNx3pS4OFo,23409
+ragaai_catalyst/dataset.py,sha256=8EbZEpcV4Fb8oO0vhYIK_WIwGyYvJ4VzwGeIZDtu2E8,23475
 ragaai_catalyst/evaluation.py,sha256=34H2bYZNSrcu0jMQgDZw1OLVbQU80PaVLo2avju8POM,20311
 ragaai_catalyst/experiment.py,sha256=8yQo1phCHlpnJ-4CqCaIbLXg_1ZlAuLGI9kqGBl-OTE,18859
 ragaai_catalyst/guard_executor.py,sha256=llPbE3DyVtrybojXknzBZj8-dtUrGBQwi9-ZiPJxGRo,3762
@@ -28,10 +28,10 @@ ragaai_catalyst/tracers/agentic_tracing/tests/ai_travel_agent.py,sha256=S4rCcKzU
 ragaai_catalyst/tracers/agentic_tracing/tests/unique_decorator_test.py,sha256=Xk1cLzs-2A3dgyBwRRnCWs7Eubki40FVonwd433hPN8,4805
 ragaai_catalyst/tracers/agentic_tracing/tracers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 ragaai_catalyst/tracers/agentic_tracing/tracers/agent_tracer.py,sha256=--wvhOJ-J2433WPatIS3wx6VFeCUIcgRT5_ZjGQDv2c,26364
-ragaai_catalyst/tracers/agentic_tracing/tracers/base.py,sha256=RFHbmzFdkl1zV4ZnM6VOAnCeTMqSKmgdH8VuWsrBwf4,40120
+ragaai_catalyst/tracers/agentic_tracing/tracers/base.py,sha256=88rX7OkOGEyVNECUrc4bYqODyulXve_-99d9ku5hBeQ,37373
 ragaai_catalyst/tracers/agentic_tracing/tracers/custom_tracer.py,sha256=l3x3uFO5ov93I7UUrUX1M06WVGy2ug2jEZ1G7o315z4,13075
 ragaai_catalyst/tracers/agentic_tracing/tracers/langgraph_tracer.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-ragaai_catalyst/tracers/agentic_tracing/tracers/llm_tracer.py,sha256=fuSVks5-OchQLXqN6T18CtDjE8ufrCcksckcC3WW-_k,30150
+ragaai_catalyst/tracers/agentic_tracing/tracers/llm_tracer.py,sha256=91aWXJGb3GDfyDfJyA7Irnk3XSyfkQaQppW_NMORGJQ,31725
 ragaai_catalyst/tracers/agentic_tracing/tracers/main_tracer.py,sha256=6hsg-Yw11v4qeELI1CWrdX8BXf-wJrTF5smBI5prgoo,15873
 ragaai_catalyst/tracers/agentic_tracing/tracers/network_tracer.py,sha256=m8CxYkl7iMiFya_lNwN1ykBc3Pmo-2pR_2HmpptwHWQ,10352
 ragaai_catalyst/tracers/agentic_tracing/tracers/tool_tracer.py,sha256=4rWL7fIJE5wN0nwh6fMWyh3OrrenZHJkNzyQXikyzQI,13771
@@ -49,6 +49,7 @@ ragaai_catalyst/tracers/agentic_tracing/utils/get_user_trace_metrics.py,sha256=v
 ragaai_catalyst/tracers/agentic_tracing/utils/llm_utils.py,sha256=wlXCuaRe81s-7FWdJ_MquXFGRZZfNrZxLIIxl-Ohbqk,15541
 ragaai_catalyst/tracers/agentic_tracing/utils/model_costs.json,sha256=GXV1s349reRMpYF_EkK-b6peSb4SY-17WnlkvpuQ4sM,294430
 ragaai_catalyst/tracers/agentic_tracing/utils/span_attributes.py,sha256=MqeRNGxzeuh9qTK0NbYMftl9V9Z0V7gMgBoHkrXP56k,1592
+ragaai_catalyst/tracers/agentic_tracing/utils/system_monitor.py,sha256=H8WNsk4v_5T6OUw4TFOzlDLjQhJwjh1nAMyMAoqMEi4,6946
 ragaai_catalyst/tracers/agentic_tracing/utils/trace_utils.py,sha256=RciiDdo2riibEoM8X0FKHaXi78y3bWwNkV8U0leqigk,3508
 ragaai_catalyst/tracers/agentic_tracing/utils/unique_decorator.py,sha256=DQHjcEuqEKsNSWaNs7SoOaq50yK4Jsl966S7mBnV-zA,5723
 ragaai_catalyst/tracers/agentic_tracing/utils/zip_list_of_unique_files.py,sha256=8SAN4pjA3XKBWlUZiDGXGh26ve1qRH_fv0VwewsfCFc,18818
@@ -61,8 +62,8 @@ ragaai_catalyst/tracers/instrumentators/llamaindex.py,sha256=SMrRlR4xM7k9HK43hak
 ragaai_catalyst/tracers/instrumentators/openai.py,sha256=14R4KW9wQCR1xysLfsP_nxS7cqXrTPoD8En4MBAaZUU,379
 ragaai_catalyst/tracers/utils/__init__.py,sha256=KeMaZtYaTojilpLv65qH08QmpYclfpacDA0U3wg6Ybw,64
 ragaai_catalyst/tracers/utils/utils.py,sha256=ViygfJ7vZ7U0CTSA1lbxVloHp4NSlmfDzBRNCJuMhis,2374
-ragaai_catalyst-2.1.5b1.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-ragaai_catalyst-2.1.5b1.dist-info/METADATA,sha256=raEM7cStptlPTu7ph3OyOU7UanQ3_7-T9dQbFXlFMbs,12764
-ragaai_catalyst-2.1.5b1.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-ragaai_catalyst-2.1.5b1.dist-info/top_level.txt,sha256=HpgsdRgEJMk8nqrU6qdCYk3di7MJkDL0B19lkc7dLfM,16
-ragaai_catalyst-2.1.5b1.dist-info/RECORD,,
+ragaai_catalyst-2.1.5b2.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+ragaai_catalyst-2.1.5b2.dist-info/METADATA,sha256=OtU5W4jpT4K2GVF82w9jYeaVglZOWOIwpPfXJNN_SmM,12764
+ragaai_catalyst-2.1.5b2.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+ragaai_catalyst-2.1.5b2.dist-info/top_level.txt,sha256=HpgsdRgEJMk8nqrU6qdCYk3di7MJkDL0B19lkc7dLfM,16
+ragaai_catalyst-2.1.5b2.dist-info/RECORD,,