ragaai-catalyst 2.1.5b25__py3-none-any.whl → 2.1.5b27__py3-none-any.whl

ragaai_catalyst/evaluation.py

@@ -510,8 +510,11 @@ class Evaluation:
             df = pd.read_csv(io.StringIO(response_text))
 
             column_list = df.columns.to_list()
+            # Remove unwanted columns
             column_list = [col for col in column_list if not col.startswith('_')]
             column_list = [col for col in column_list if '.' not in col]
+            # Remove _claims_ columns
+            column_list = [col for col in column_list if '_claims_' not in col]
             return df[column_list]
         else:
             return pd.DataFrame()

ragaai_catalyst/tracers/agentic_tracing/tracers/agent_tracer.py

@@ -106,48 +106,42 @@ class AgentTracerMixin:
                     if gt is not None:
                         span = self.span(name)
                         span.add_gt(gt)
-                    # Set agent context before initializing
-                    component_id = str(uuid.uuid4())
-                    hash_id = top_level_hash_id
-
-                    # Store the component ID in the instance
-                    self._agent_component_id = component_id
-
-                    # Get parent agent ID if exists
-                    parent_agent_id = tracer.current_agent_id.get()
-
-                    # Create agent component
-                    agent_component = tracer.create_agent_component(
-                        component_id=component_id,
-                        hash_id=hash_id,
-                        name=name,
-                        agent_type=agent_type,
-                        version=version,
-                        capabilities=capabilities or [],
-                        start_time=datetime.now().astimezone().isoformat(),
-                        memory_used=0,
-                        input_data=tracer._sanitize_input(args, kwargs),
-                        output_data=None,
-                        children=[],
-                        parent_id=parent_agent_id,
-                    )
-
-                    # Store component for later updates
-                    if not hasattr(tracer, "_agent_components"):
-                        tracer._agent_components = {}
-                    tracer._agent_components[component_id] = agent_component
 
-                    # If this is a nested agent, add it to parent's children
-                    if parent_agent_id:
-                        parent_children = tracer.agent_children.get()
-                        parent_children.append(agent_component)
-                        tracer.agent_children.set(parent_children)
-                    else:
-                        # Only add to root components if no parent
-                        tracer.add_component(agent_component)
-
-                    # Call original __init__ with this agent as current
-                    token = tracer.current_agent_id.set(component_id)
+                    if not hasattr(self, '_agent_component_id'):
+                        component_id = str(uuid.uuid4())
+                        self._agent_component_id = component_id
+                        
+                        # Get parent agent ID if exists
+                        parent_agent_id = tracer.current_agent_id.get()
+                        
+                        agent_component = tracer.create_agent_component(
+                            component_id=component_id,
+                            hash_id=top_level_hash_id,
+                            name=name,
+                            agent_type=agent_type,
+                            version=version,
+                            capabilities=capabilities or [],
+                            start_time=datetime.now().astimezone().isoformat(),
+                            memory_used=0,
+                            input_data=tracer._sanitize_input(args, kwargs),
+                            output_data=None,
+                            children=[],
+                            parent_id=parent_agent_id,
+                        )
+                        
+                        if not hasattr(tracer, "_agent_components"):
+                            tracer._agent_components = {}
+                        tracer._agent_components[component_id] = agent_component
+                        
+                        # For class agents, only add to parent's children if parent exists
+                        if parent_agent_id and parent_agent_id in tracer._agent_components:
+                            parent_component = tracer._agent_components[parent_agent_id]
+                            if not hasattr(parent_component, "children"):
+                                parent_component["children"] = []
+                            if component_id not in parent_component["children"]:
+                                parent_component["children"].append(component_id)
+                    
+                    token = tracer.current_agent_id.set(self._agent_component_id)
                     try:
                         original_init(self, *args, **kwargs)
                     finally:
@@ -160,7 +154,6 @@ class AgentTracerMixin:
                         if callable(attr_value):
 
                             def wrap_method(method):
-                                @self.file_tracker.trace_decorator
                                 @functools.wraps(method)
                                 def wrapped_method(self, *args, **kwargs):
                                     gt = kwargs.get("gt") if kwargs else None
@@ -225,15 +218,60 @@ class AgentTracerMixin:
                             setattr(target, attr_name, wrap_method(attr_value))
 
                 # Replace __init__ with wrapped version
+
                 target.__init__ = wrapped_init
+
+                # Wrap all methods to maintain parent-child relationship
+                for attr_name, attr_value in target.__dict__.items():
+                    if callable(attr_value) and not attr_name.startswith('__'):
+                        original_method = attr_value
+                        
+                        def create_wrapper(method):
+                            @self.file_tracker.trace_decorator
+                            @functools.wraps(method)
+                            def method_wrapper(self, *args, **kwargs):
+                                gt = kwargs.get("gt") if kwargs else None
+                                if gt is not None:
+                                    span = tracer.span(name)
+                                    span.add_gt(gt)
+                                # Use the class instance's agent ID as parent
+                                parent_id = getattr(self, '_agent_component_id', None)
+                                if parent_id:
+                                    if asyncio.iscoroutinefunction(method):
+                                        return tracer._trace_agent_execution(
+                                            method.__get__(self, type(self)),
+                                            name,
+                                            agent_type,
+                                            version,
+                                            capabilities,
+                                            top_level_hash_id,
+                                            *args,
+                                            **kwargs,
+                                        )
+                                    else:
+                                        return tracer._trace_sync_agent_execution(
+                                            method.__get__(self, type(self)),
+                                            name,
+                                            agent_type,
+                                            version,
+                                            capabilities,
+                                            top_level_hash_id,
+                                            *args,
+                                            **kwargs,
+                                        )
+                                else:
+                                    return method(self, *args, **kwargs)
+                            return method_wrapper
+                        
+                        setattr(target, attr_name, create_wrapper(original_method))
+
                 return target
             else:
-                # For function decorators, use existing sync/async tracing
-                is_async = asyncio.iscoroutinefunction(target)
-                if is_async:
-
-                    async def wrapper(*args, **kwargs):
-                        return await self._trace_agent_execution(
+                # For non-class targets (e.g., functions), use existing function wrapping logic
+                @functools.wraps(target)
+                def wrapper(*args, **kwargs):
+                    if asyncio.iscoroutinefunction(target):
+                        return tracer._trace_agent_execution(
                             target,
                             name,
                             agent_type,
@@ -243,12 +281,8 @@ class AgentTracerMixin:
                             *args,
                             **kwargs,
                         )
-
-                    return wrapper
-                else:
-
-                    def wrapper(*args, **kwargs):
-                        return self._trace_sync_agent_execution(
+                    else:
+                        return tracer._trace_sync_agent_execution(
                             target,
                             name,
                             agent_type,
@@ -258,16 +292,13 @@ class AgentTracerMixin:
                             *args,
                             **kwargs,
                         )
-
-                    return wrapper
+                return wrapper
 
         return decorator
 
     def _trace_sync_agent_execution(
-            self, func, name, agent_type, version, capabilities, top_level_hash_id, *args, **kwargs
+        self, func, name, agent_type, version, capabilities, top_level_hash_id, *args, **kwargs
     ):
-        hash_id = top_level_hash_id
-
         """Synchronous version of agent tracing"""
         if not self.is_active:
             return func(*args, **kwargs)
@@ -303,7 +334,7 @@ class AgentTracerMixin:
 
         try:
             # Execute the agent
-            result = self.file_tracker.trace_wrapper(func)(*args, **kwargs)
+            result = func(*args, **kwargs)
 
             # Calculate resource usage
             end_memory = psutil.Process().memory_info().rss
@@ -318,7 +349,7 @@ class AgentTracerMixin:
             # Create agent component with children and parent if exists
             agent_component = self.create_agent_component(
                 component_id=component_id,
-                hash_id=hash_id,
+                hash_id=top_level_hash_id,
                 name=name,
                 agent_type=agent_type,
                 version=version,
@@ -331,12 +362,17 @@ class AgentTracerMixin:
                 parent_id=parent_agent_id,
             )
 
-            # Add this component as a child to parent's children list
-            parent_children.append(agent_component)
-            self.agent_children.set(parent_children)
+            # Store component for updates
+            if not hasattr(self, "_agent_components"):
+                self._agent_components = {}
+            self._agent_components[component_id] = agent_component
 
-            # Only add to root components if no parent
-            if not parent_agent_id:
+            # Only add to hierarchy if this is a root component (no parent)
+            # or if the parent explicitly added it as a child
+            if parent_agent_id:
+                parent_children.append(agent_component)
+                self.agent_children.set(parent_children)
+            else:
                 self.add_component(agent_component)
 
             return result
@@ -351,16 +387,10 @@ class AgentTracerMixin:
             # Get children even in case of error
             children = self.agent_children.get()
 
-            # Set parent_id for all children
-            for child in children:
-                child["parent_id"] = component_id
-
-            # End tracking network calls for this component
-            self.end_component(component_id)
-
+            # Create error component
             agent_component = self.create_agent_component(
                 component_id=component_id,
-                hash_id=hash_id,
+                hash_id=top_level_hash_id,
                 name=name,
                 agent_type=agent_type,
                 version=version,
@@ -373,16 +403,20 @@ class AgentTracerMixin:
                 children=children,
                 parent_id=parent_agent_id,  # Add parent ID if exists
             )
-            # If this is a nested agent, add it to parent's children
+
+            # Store component for updates
+            if not hasattr(self, "_agent_components"):
+                self._agent_components = {}
+            self._agent_components[component_id] = agent_component
+
+            # Only add to hierarchy if this is a root component (no parent)
+            # or if the parent explicitly added it as a child
             if parent_agent_id:
-                parent_component = self._agent_components.get(parent_agent_id)
-                if parent_component:
-                    if "children" not in parent_component["data"]:
-                        parent_component["data"]["children"] = []
-                    parent_component["data"]["children"].append(agent_component)
+                parent_children.append(agent_component)
+                self.agent_children.set(parent_children)
             else:
                 # Only add to root components if no parent
-                self.add_component(agent_component)
+                self.add_component(agent_component, is_error=True)
 
             raise
         finally:
@@ -424,7 +458,7 @@ class AgentTracerMixin:
 
         try:
             # Execute the agent
-            result = await self.file_tracker.trace_wrapper(func)(*args, **kwargs)
+            result = await func(*args, **kwargs)
 
             # Calculate resource usage
             end_memory = psutil.Process().memory_info().rss
@@ -451,12 +485,17 @@ class AgentTracerMixin:
                 parent_id=parent_agent_id,
             )
 
-            # Add this component as a child to parent's children list
-            parent_children.append(agent_component)
-            self.agent_children.set(parent_children)
+            # Store component for updates
+            if not hasattr(self, "_agent_components"):
+                self._agent_components = {}
+            self._agent_components[component_id] = agent_component
 
-            # Only add to root components if no parent
-            if not parent_agent_id:
+            # Only add to hierarchy if this is a root component (no parent)
+            # or if the parent explicitly added it as a child
+            if parent_agent_id:
+                parent_children.append(agent_component)
+                self.agent_children.set(parent_children)
+            else:
                 self.add_component(agent_component)
 
             return result
@@ -471,13 +510,7 @@ class AgentTracerMixin:
             # Get children even in case of error
             children = self.agent_children.get()
 
-            # Set parent_id for all children
-            for child in children:
-                child["parent_id"] = component_id
-
-            # End tracking network calls for this component
-            self.end_component(component_id)
-
+            # Create error component
             agent_component = self.create_agent_component(
                 component_id=component_id,
                 hash_id=hash_id,
@@ -494,16 +527,19 @@ class AgentTracerMixin:
                 parent_id=parent_agent_id,  # Add parent ID if exists
             )
 
-            # If this is a nested agent, add it to parent's children
+            # Store component for updates
+            if not hasattr(self, "_agent_components"):
+                self._agent_components = {}
+            self._agent_components[component_id] = agent_component
+
+            # Only add to hierarchy if this is a root component (no parent)
+            # or if the parent explicitly added it as a child
             if parent_agent_id:
-                parent_component = self._agent_components.get(parent_agent_id)
-                if parent_component:
-                    if "children" not in parent_component["data"]:
-                        parent_component["data"]["children"] = []
-                    parent_component["data"]["children"].append(agent_component)
+                parent_children.append(agent_component)
+                self.agent_children.set(parent_children)
             else:
                 # Only add to root components if no parent
-                self.add_component(agent_component)
+                self.add_component(agent_component, is_error=True)
 
             raise
         finally:

ragaai_catalyst/tracers/agentic_tracing/tracers/base.py

@@ -137,6 +137,7 @@ class BaseTracer:
         """Initialize a new trace"""
         self.tracking = True
         self.trace_id = str(uuid.uuid4())
+        self.file_tracker.trace_main_file()
         self.system_monitor = SystemMonitor(self.trace_id)
         threading.Thread(target=self._track_memory_usage).start()
         threading.Thread(target=self._track_cpu_usage).start()

ragaai_catalyst/tracers/agentic_tracing/tracers/custom_tracer.py

@@ -41,7 +41,6 @@ class CustomTracerMixin:
             # Check if the function is async
             is_async = asyncio.iscoroutinefunction(func)
 
-            @self.file_tracker.trace_decorator
             @functools.wraps(func)
             async def async_wrapper(*args, **kwargs):
                 async_wrapper.metadata = metadata
@@ -53,7 +52,6 @@ class CustomTracerMixin:
                     func, name or func.__name__, custom_type, version, trace_variables, *args, **kwargs
                 )
 
-            @self.file_tracker.trace_decorator
             @functools.wraps(func)
             def sync_wrapper(*args, **kwargs):
                 sync_wrapper.metadata = metadata
@@ -104,7 +102,7 @@ class CustomTracerMixin:
 
         try:
             # Execute the function
-            result = self.file_tracker.trace_wrapper(func)(*args, **kwargs)
+            result = func(*args, **kwargs)
 
             # Calculate resource usage
             end_time = datetime.now().astimezone().isoformat()
@@ -160,7 +158,7 @@ class CustomTracerMixin:
                 error=error_component
             )
 
-            self.add_component(custom_component)
+            self.add_component(custom_component, is_error=True)
             raise
 
     async def _trace_custom_execution(self, func, name, custom_type, version, trace_variables, *args, **kwargs):
@@ -192,7 +190,7 @@ class CustomTracerMixin:
 
         try:
             # Execute the function
-            result = await self.file_tracker.trace_wrapper(func)(*args, **kwargs)
+            result = await func(*args, **kwargs)
 
             # Calculate resource usage
             end_time = datetime.now().astimezone().isoformat()
@@ -240,7 +238,7 @@ class CustomTracerMixin:
                 output_data=None,
                 error=error_component
             )
-            self.add_component(custom_component)
+            self.add_component(custom_component, is_error=True)
             raise
 
     def create_custom_component(self, **kwargs):