ragaai-catalyst 2.1.4.1b0__py3-none-any.whl → 2.1.5__py3-none-any.whl

ragaai_catalyst/tracers/agentic_tracing/tracers/main_tracer.py

@@ -6,6 +6,7 @@ import uuid
 import os
 import builtins
 from pathlib import Path
+import logging
 
 from .base import BaseTracer
 from .llm_tracer import LLMTracerMixin
@@ -57,10 +58,12 @@ class AgenticTracing(
 
         self.project_name = user_detail["project_name"]
         self.project_id = user_detail["project_id"]
-        # self.dataset_name = user_detail["dataset_name"]
         self.trace_user_detail = user_detail["trace_user_detail"]
         self.base_url = f"{RagaAICatalyst.BASE_URL}"
         self.timeout = 10
+        
+        # Add warning flag
+        self._warning_shown = False
 
         BaseTracer.__init__(self, user_detail)
 
@@ -84,27 +87,23 @@ class AgenticTracing(
             self.auto_instrument_custom = True
         else:
             # Set global active state
-            self.is_active = (
-                any(auto_instrumentation.values())
-                if isinstance(auto_instrumentation, dict)
-                else bool(auto_instrumentation)
-            )
+            self.is_active = True
 
             # Set individual components
             if isinstance(auto_instrumentation, dict):
-                self.auto_instrument_llm = auto_instrumentation.get("llm", False)
-                self.auto_instrument_tool = auto_instrumentation.get("tool", False)
-                self.auto_instrument_agent = auto_instrumentation.get("agent", False)
+                self.auto_instrument_llm = auto_instrumentation.get("llm", True)
+                self.auto_instrument_tool = auto_instrumentation.get("tool", True)
+                self.auto_instrument_agent = auto_instrumentation.get("agent", True)
                 self.auto_instrument_user_interaction = auto_instrumentation.get(
-                    "user_interaction", False
+                    "user_interaction", True
                 )
                 self.auto_instrument_file_io = auto_instrumentation.get(
-                    "file_io", False
+                    "file_io", True
                 )
                 self.auto_instrument_network = auto_instrumentation.get(
-                    "network", False
+                    "network", True
                 )
-                self.auto_instrument_custom = auto_instrumentation.get("custom", False)
+                self.auto_instrument_custom = auto_instrumentation.get("custom", True)
             else:
                 # If boolean provided, apply to all components
                 self.auto_instrument_llm = bool(auto_instrumentation)
@@ -120,9 +119,6 @@ class AgenticTracing(
         self.component_network_calls = {}  # Store network calls per component
         self.component_user_interaction = {}
 
-        # Create output directory if it doesn't exist
-        self.output_dir = Path("./traces")  # Using default traces directory
-        self.output_dir.mkdir(exist_ok=True)
 
     def start_component(self, component_id: str):
         """Start tracking network calls for a component"""
@@ -137,27 +133,38 @@ class AgenticTracing(
             self.network_tracer.network_calls.copy()
         )
         self.network_tracer.network_calls = []  # Reset for next component
-        # self.component_user_interaction[component_id] = [interaction for interaction in self.user_interaction_tracer.interactions if interaction.get('component_id') == component_id]
+
+        # Store user interactions for the component
         for interaction in self.user_interaction_tracer.interactions:
             interaction_component_id = interaction.get("component_id")
             if interaction_component_id not in self.component_user_interaction:
                 self.component_user_interaction[interaction_component_id] = []
             if interaction not in self.component_user_interaction[interaction_component_id]:
                 self.component_user_interaction[interaction_component_id].append(interaction)
+                
+        # Only reset component_id if it matches the current one
+        # This ensures we don't reset a parent's component_id when a child component ends
+        if self.current_component_id.get() == component_id:
+            # Get the parent agent's component_id if it exists
+            parent_agent_id = self.current_agent_id.get()
+            # If there's a parent agent, set the component_id back to the parent's
+            if parent_agent_id:
+                self.current_component_id.set(parent_agent_id)
+                self.user_interaction_tracer.component_id.set(parent_agent_id)
+            else:
+                # Only reset to None if there's no parent
+                self.current_component_id.set(None)
+                self.user_interaction_tracer.component_id.set(None)
 
     def start(self):
         """Start tracing"""
-        if not self.is_active:
-            return
+        self.is_active = True
 
         # Setup user interaction tracing
         self.user_interaction_tracer.project_id.set(self.project_id)
         self.user_interaction_tracer.trace_id.set(self.trace_id)
         self.user_interaction_tracer.tracer = self
         self.user_interaction_tracer.component_id.set(self.current_component_id.get())
-        builtins.print = self.user_interaction_tracer.traced_print
-        builtins.input = self.user_interaction_tracer.traced_input
-        builtins.open = self.user_interaction_tracer.traced_open
 
         # Start base tracer (includes system info and resource monitoring)
         super().start()
@@ -166,24 +173,13 @@ class AgenticTracing(
         self.network_tracer.activate_patches()
 
         # take care of the auto instrumentation
-        if self.auto_instrument_llm:
-            self.instrument_llm_calls()
-
-        if self.auto_instrument_tool:
-            self.instrument_tool_calls()
-
-        if self.auto_instrument_agent:
-            self.instrument_agent_calls()
-
-        if self.auto_instrument_custom:
-            self.instrument_custom_calls()
-
         if self.auto_instrument_user_interaction:
-
             ToolTracerMixin.instrument_user_interaction_calls(self)
             LLMTracerMixin.instrument_user_interaction_calls(self)
             AgentTracerMixin.instrument_user_interaction_calls(self)
             CustomTracerMixin.instrument_user_interaction_calls(self)
+            builtins.print = self.user_interaction_tracer.traced_print
+            builtins.input = self.user_interaction_tracer.traced_input
 
         if self.auto_instrument_network:
             ToolTracerMixin.instrument_network_calls(self)
@@ -191,9 +187,24 @@ class AgenticTracing(
             AgentTracerMixin.instrument_network_calls(self)
             CustomTracerMixin.instrument_network_calls(self)
 
-        # These will be implemented later
-        # if self.auto_instrument_file_io:
-        #     self.instrument_file_io_calls()
+        if self.auto_instrument_file_io:
+            ToolTracerMixin.instrument_file_io_calls(self)
+            LLMTracerMixin.instrument_file_io_calls(self)
+            AgentTracerMixin.instrument_file_io_calls(self)
+            CustomTracerMixin.instrument_file_io_calls(self)
+            builtins.open = self.user_interaction_tracer.traced_open
+            
+        if self.auto_instrument_llm:
+            self.instrument_llm_calls()
+
+        if self.auto_instrument_tool:
+            self.instrument_tool_calls()
+
+        if self.auto_instrument_agent:
+            self.instrument_agent_calls()
+
+        if self.auto_instrument_custom:
+            self.instrument_custom_calls()
 
     def stop(self):
         """Stop tracing and save results"""
@@ -225,6 +236,8 @@ class AgenticTracing(
         total_cost = 0.0
         total_tokens = 0
 
+        processed_components = set()
+
         def process_component(component):
             nonlocal total_cost, total_tokens
             # Convert component to dict if it's an object
@@ -232,6 +245,11 @@ class AgenticTracing(
                 component.__dict__ if hasattr(component, "__dict__") else component
             )
 
+            comp_id = comp_dict.get("id") or comp_dict.get("component_id")
+            if comp_id in processed_components:
+                return  # Skip if already processed
+            processed_components.add(comp_id)
+
             if comp_dict.get("type") == "llm":
                 info = comp_dict.get("info", {})
                 if isinstance(info, dict):
@@ -298,6 +316,47 @@ class AgenticTracing(
             ]
         }
 
+        if component_data == None or component_data == {} or component_data.get("type", None) == None:
+            # Only show warning if it hasn't been shown before
+            if not self._warning_shown:
+                import toml
+                import os
+                from pathlib import Path
+
+                # Load supported LLM calls from TOML file
+                current_dir = Path(__file__).parent
+                toml_path = current_dir / "../utils/supported_llm_provider.toml"
+                try:
+                    with open(toml_path, "r") as f:
+                        config = toml.load(f)
+                        supported_calls = ", ".join(config["supported_llm_calls"])
+                except Exception as e:
+                    supported_calls = "Error loading supported LLM calls"
+
+                # ANSI escape codes for colors and formatting
+                RED = "\033[91m"
+                BOLD = "\033[1m"
+                RESET = "\033[0m"
+                BIG = "\033[1;2m"  # Makes text slightly larger in supported terminals
+
+                warning_msg = f"""{RED}{BOLD}{BIG}
+╔════════════════════════ COMPONENT DATA INCOMPLETE ════════════════════════╗
+║                                                                          ║
+║  Please ensure these requirements:                                       ║
+║  ✗ trace_llm decorator must have a stand alone llm call                 ║
+║  ✗ trace_tool decorator must be a stand alone tool/function call        ║
+║  ✗ trace_agent decorator can have multiple/nested llm/tool/agent calls  ║
+║                                                                          ║
+║  Supported LLM calls:                                                    ║
+║  {supported_calls}                                                       ║
+║                                                                          ║
+╚══════════════════════════════════════════════════════════════════════════╝
+{RESET}"""
+                # Use logger.warning for the message
+                logging.warning(warning_msg)
+                self._warning_shown = True
+            return
+
         if component_data["type"] == "llm":
             component = LLMComponent(**filtered_data)
         elif component_data["type"] == "agent":
@@ -309,7 +368,7 @@ class AgenticTracing(
 
         # Check if there's an active agent context
         current_agent_id = self.current_agent_id.get()
-        if current_agent_id and component_data["type"] in ["llm", "tool"]:
+        if current_agent_id and component_data["type"] in ["llm", "tool", "custom"]:
             # Add this component as a child of the current agent
             current_children = self.agent_children.get()
             current_children.append(component_data)
@@ -319,67 +378,7 @@ class AgenticTracing(
             super().add_component(component)
 
         # Handle error case
-        if is_error:
-            # Get the parent component if it exists
-            parent_id = component_data.get("parent_id")
-            children = self.agent_children.get()
-
-            # Set parent_id for all children
-            for child in children:
-                child["parent_id"] = parent_id
-
-            agent_tracer_mixin = AgentTracerMixin()
-            agent_tracer_mixin.component_network_calls = self.component_network_calls
-            agent_tracer_mixin.component_user_interaction = (
-                self.component_user_interaction
-            )
-
-            agent_tracer_mixin.span_attributes_dict[self.current_agent_name.get()] = (
-                SpanAttributes(self.current_agent_name.get())
-            )
-
-            # Create parent component with error info
-            parent_component = agent_tracer_mixin.create_agent_component(
-                component_id=parent_id,
-                hash_id=str(uuid.uuid4()),
-                source_hash_id=None,
-                type="agent",
-                name=self.current_agent_name.get(),
-                agent_type=self.agent_type.get(),
-                version=self.version.get(),
-                capabilities=self.capabilities.get(),
-                start_time=self.start_time,
-                end_time=datetime.now().astimezone().isoformat(),
-                memory_used=0,
-                input_data=self.input_data,
-                output_data=None,
-                children=children,
-                parent_id=None,  # Add parent ID if exists
-            )
-
-            filtered_data = {
-                k: v
-                for k, v in parent_component.items()
-                if k
-                in [
-                    "id",
-                    "hash_id",
-                    "source_hash_id",
-                    "type",
-                    "name",
-                    "start_time",
-                    "end_time",
-                    "parent_id",
-                    "info",
-                    "data",
-                    "network_calls",
-                    "interactions",
-                    "error",
-                ]
-            }
-            parent_agent_component = AgentComponent(**filtered_data)
-            # Add the parent component to trace and stop tracing
-            super().add_component(parent_agent_component)
+        if is_error and not self.current_agent_id.get():
             self.stop()
 
     def __enter__(self):

ragaai_catalyst/tracers/agentic_tracing/tracers/network_tracer.py

@@ -41,7 +41,7 @@ class NetworkTracer:
         
         # Extract protocol from URL
         protocol = "https" if url.startswith("https") else "http"
-        
+            
         self.network_calls.append(
             {
                 "url": url,
@@ -57,11 +57,11 @@ class NetworkTracer:
                 "parent_id": None,  # Will be set by the component
                 "request": {
                     "headers": request_headers,
-                    "body": request_body[:1000] if request_body else None,  # Limit to 1000 chars
+                    "body": request_body if request_body else None,
                 },
                 "response": {
                     "headers": response_headers,
-                    "body": response_body[:1000] if response_body else None,  # Limit to 1000 chars
+                    "body": response_body if response_body else None,
                 },
                 "error": str(error) if error else None,
             }