ragaai-catalyst 2.1.5.1b2__py3-none-any.whl → 2.1.6b0__py3-none-any.whl

ragaai_catalyst/synthetic_data_generation.py

@@ -3,7 +3,7 @@ import ast
 import csv
 import json
 import random
-import PyPDF2
+import pypdf
 import markdown
 import pandas as pd
 from tqdm import tqdm
@@ -11,7 +11,6 @@ from tqdm import tqdm
 import openai
 import tiktoken
 import litellm
-import google.generativeai as genai
 from groq import Groq
 from litellm import completion
 
@@ -105,6 +104,9 @@ class SyntheticDataGeneration:
                     raise Exception(f"{e}")
 
                 else:
+                    if "'utf-8' codec can't encode characters" in str(e):
+                        print('Encountered non utf charactes, retrying with processed text')
+                        text = str(text.encode('utf-8',errors='ignore'))
                     print(f"Retrying...")
                     continue
         
@@ -163,7 +165,9 @@ class SyntheticDataGeneration:
         elif provider == "gemini":
             if api_key is None and os.getenv("GEMINI_API_KEY") is None and api_base is None and internal_llm_proxy is None:
                 raise ValueError("API key must be provided for Gemini.")
-            genai.configure(api_key=api_key or os.getenv("GEMINI_API_KEY"))
+            if api_key:
+                os.environ["GEMINI_API_KEY"] = api_key
+            # genai.configure(api_key=api_key or os.getenv("GEMINI_API_KEY"))
         
         elif provider == "openai":
             if api_key is None and os.getenv("OPENAI_API_KEY") is None and internal_llm_proxy is None:
@@ -469,7 +473,7 @@ class SyntheticDataGeneration:
         """
         text = ""
         with open(file_path, 'rb') as file:
-            pdf_reader = PyPDF2.PdfReader(file)
+            pdf_reader = pypdf.PdfReader(file)
             for page in pdf_reader.pages:
                 text += page.extract_text()
         return text

ragaai_catalyst/tracers/agentic_tracing/upload/trace_uploader.py

@@ -323,7 +323,7 @@ def shutdown():
     global _executor
     if _executor:
         logger.info("Shutting down executor")
-        _executor.shutdown(wait=False)
+        _executor.shutdown(wait=True)
         _executor = None
 
 # Register shutdown handler

ragaai_catalyst/tracers/agentic_tracing/utils/trace_utils.py

@@ -63,3 +63,374 @@ def log_event(event_data, log_file_path):
     event_data = asdict(event_data)
     with open(log_file_path, "a") as f:
         f.write(json.dumps(event_data) + "\n")
+
+
+def process_child_interactions(child, interaction_id, interactions):
+    """
+    Helper method to process child interactions recursively.
+    
+    Args:
+        child (dict): The child span to process
+        interaction_id (int): Current interaction ID
+        interactions (list): List of interactions to append to
+        
+    Returns:
+        int: Next interaction ID to use
+    """
+    child_type = child.get("type")
+
+    if child_type == "tool":
+        # Tool call start
+        interactions.append(
+            {
+                "id": str(interaction_id),
+                "span_id": child.get("id"),
+                "interaction_type": "tool_call_start",
+                "name": child.get("name"),
+                "content": {
+                    "parameters": [
+                        child.get("data", {}).get("input", {}).get("args"),
+                        child.get("data", {}).get("input", {}).get("kwargs"),
+                    ]
+                },
+                "timestamp": child.get("start_time"),
+                "error": child.get("error"),
+            }
+        )
+        interaction_id += 1
+
+        # Tool call end
+        interactions.append(
+            {
+                "id": str(interaction_id),
+                "span_id": child.get("id"),
+                "interaction_type": "tool_call_end",
+                "name": child.get("name"),
+                "content": {
+                    "returns": child.get("data", {}).get("output"),
+                },
+                "timestamp": child.get("end_time"),
+                "error": child.get("error"),
+            }
+        )
+        interaction_id += 1
+
+    elif child_type == "llm":
+        interactions.append(
+            {
+                "id": str(interaction_id),
+                "span_id": child.get("id"),
+                "interaction_type": "llm_call_start",
+                "name": child.get("name"),
+                "content": {
+                    "prompt": child.get("data", {}).get("input"),
+                },
+                "timestamp": child.get("start_time"),
+                "error": child.get("error"),
+            }
+        )
+        interaction_id += 1
+
+        interactions.append(
+            {
+                "id": str(interaction_id),
+                "span_id": child.get("id"),
+                "interaction_type": "llm_call_end",
+                "name": child.get("name"),
+                "content": {"response": child.get("data", {}).get("output")},
+                "timestamp": child.get("end_time"),
+                "error": child.get("error"),
+            }
+        )
+        interaction_id += 1
+
+    elif child_type == "agent":
+        interactions.append(
+            {
+                "id": str(interaction_id),
+                "span_id": child.get("id"),
+                "interaction_type": "agent_call_start",
+                "name": child.get("name"),
+                "content": None,
+                "timestamp": child.get("start_time"),
+                "error": child.get("error"),
+            }
+        )
+        interaction_id += 1
+
+        # Process nested children recursively
+        if "children" in child.get("data", {}):
+            for nested_child in child["data"]["children"]:
+                interaction_id = process_child_interactions(
+                    nested_child, interaction_id, interactions
+                )
+
+        interactions.append(
+            {
+                "id": str(interaction_id),
+                "span_id": child.get("id"),
+                "interaction_type": "agent_call_end",
+                "name": child.get("name"),
+                "content": child.get("data", {}).get("output"),
+                "timestamp": child.get("end_time"),
+                "error": child.get("error"),
+            }
+        )
+        interaction_id += 1
+
+    else:
+        interactions.append(
+            {
+                "id": str(interaction_id),
+                "span_id": child.get("id"),
+                "interaction_type": f"{child_type}_call_start",
+                "name": child.get("name"),
+                "content": child.get("data", {}),
+                "timestamp": child.get("start_time"),
+                "error": child.get("error"),
+            }
+        )
+        interaction_id += 1
+
+        interactions.append(
+            {
+                "id": str(interaction_id),
+                "span_id": child.get("id"),
+                "interaction_type": f"{child_type}_call_end",
+                "name": child.get("name"),
+                "content": child.get("data", {}),
+                "timestamp": child.get("end_time"),
+                "error": child.get("error"),
+            }
+        )
+        interaction_id += 1
+
+    # Process additional interactions and network calls
+    if "interactions" in child:
+        for interaction in child["interactions"]:
+            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"]:
+            network_call = {}
+            network_call["id"] = str(interaction_id)
+            network_call["span_id"] = child.get("id")
+            network_call["interaction_type"] = "network_call"
+            network_call["name"] = None
+            network_call["content"] = {
+                "request": {
+                    "url": child_network_call.get("url"),
+                    "method": child_network_call.get("method"),
+                    "headers": child_network_call.get("headers"),
+                },
+                "response": {
+                    "status_code": child_network_call.get("status_code"),
+                    "headers": child_network_call.get("response_headers"),
+                    "body": child_network_call.get("response_body"),
+                },
+            }
+            network_call["timestamp"] = child_network_call.get("start_time")
+            network_call["error"] = child_network_call.get("error")
+            interactions.append(network_call)
+            interaction_id += 1
+
+    return interaction_id
+
+
+def format_interactions(trace) -> dict:
+    """
+    Format interactions from trace data into a standardized format.
+    Returns a dictionary containing formatted interactions based on trace data.
+
+    The function processes spans from self.trace and formats them into interactions
+    of various types including: agent_start, agent_end, input, output, tool_call_start,
+    tool_call_end, llm_call, file_read, file_write, network_call.
+
+    Returns:
+        dict: A dictionary with "workflow" key containing a list of interactions
+                sorted by timestamp.
+    """
+    interactions = []
+    interaction_id = 1
+
+    if 'data' not in trace or not trace['data'][0]["spans"]:
+        return {"workflow": []}
+
+    for span in trace['data'][0]["spans"]:
+        # Process agent spans
+        if span['type'] == "agent":
+            # Add agent_start interaction
+            interactions.append(
+                {
+                    "id": str(interaction_id),
+                    "span_id": span['id'],
+                    "interaction_type": "agent_call_start",
+                    "name": span['name'],
+                    "content": None,
+                    "timestamp": span['start_time'],
+                    "error": span['error'],
+                }
+            )
+            interaction_id += 1
+
+            # Process children of agent recursively
+            if "children" in span['data']:
+                for child in span['data']["children"]:
+                    interaction_id = process_child_interactions(
+                        child, interaction_id, interactions
+                    )
+
+            # Add agent_end interaction
+            interactions.append(
+                {
+                    "id": str(interaction_id),
+                    "span_id": span['id'],
+                    "interaction_type": "agent_call_end",
+                    "name": span['name'],
+                    "content": span['data'].get("output"),
+                    "timestamp": span['end_time'],
+                    "error": span['error'],
+                }
+            )
+            interaction_id += 1
+
+        elif span['type'] == "tool":
+            interactions.append(
+                {
+                    "id": str(interaction_id),
+                    "span_id": span['id'],
+                    "interaction_type": "tool_call_start",
+                    "name": span['name'],
+                    "content": {
+                        "prompt": span['data'].get("input"),
+                        "response": span['data'].get("output"),
+                    },
+                    "timestamp": span['start_time'],
+                    "error": span['error'],
+                }
+            )
+            interaction_id += 1
+
+            interactions.append(
+                {
+                    "id": str(interaction_id),
+                    "span_id": span['id'],
+                    "interaction_type": "tool_call_end",
+                    "name": span['name'],
+                    "content": {
+                        "prompt": span['data'].get("input"),
+                        "response": span['data'].get("output"),
+                    },
+                    "timestamp": span['end_time'],
+                    "error": span['error'],
+                }
+            )
+            interaction_id += 1
+
+        elif span['type'] == "llm":
+            interactions.append(
+                {
+                    "id": str(interaction_id),
+                    "span_id": span['id'],
+                    "interaction_type": "llm_call_start",
+                    "name": span['name'],
+                    "content": {
+                        "prompt": span['data'].get("input"),
+                    },
+                    "timestamp": span['start_time'],
+                    "error": span['error']
+                }
+            )
+            interaction_id += 1
+
+            interactions.append(
+                {
+                    "id": str(interaction_id),
+                    "span_id": span['id'],
+                    "interaction_type": "llm_call_end",
+                    "name": span['name'],
+                    "content": {"response": span['data'].get("output")},
+                    "timestamp": span['end_time'],
+                    "error": span['error'],
+                }
+            )
+            interaction_id += 1
+
+        else:
+            interactions.append(
+                {
+                    "id": str(interaction_id),
+                    "span_id": span['id'],
+                    "interaction_type": f"{span['type']}_call_start",
+                    "name": span['name'],
+                    "content": span['data'],
+                    "timestamp": span['start_time'],
+                    "error": span['error'],
+                }
+            )
+            interaction_id += 1
+
+            interactions.append(
+                {
+                    "id": str(interaction_id),
+                    "span_id": span['id'],
+                    "interaction_type": f"{span['type']}_call_end",
+                    "name": span['name'],
+                    "content": span['data'],
+                    "timestamp": span['end_time'],
+                    "error": span['error'],
+                }
+            )
+            interaction_id += 1
+
+        # Process interactions from span.data if they exist
+        if 'interactions' in span:
+            for span_interaction in span['interactions']:
+                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 'network_calls' in span:
+            for span_network_call in span['network_calls']:
+                network_call = {}
+                network_call["id"] = str(interaction_id)
+                network_call["span_id"] = span['id']
+                network_call["interaction_type"] = "network_call"
+                network_call["name"] = None
+                network_call["content"] = {
+                    "request": {
+                        "url": span_network_call.get("url"),
+                        "method": span_network_call.get("method"),
+                        "headers": span_network_call.get("headers"),
+                    },
+                    "response": {
+                        "status_code": span_network_call.get("status_code"),
+                        "headers": span_network_call.get("response_headers"),
+                        "body": span_network_call.get("response_body"),
+                    },
+                }
+                network_call["timestamp"] = span_network_call.get("timestamp")
+                network_call["error"] = span_network_call.get("error")
+                interactions.append(network_call)
+                interaction_id += 1
+
+    # Sort interactions by timestamp
+    sorted_interactions = sorted(
+        interactions, key=lambda x: x["timestamp"] if x["timestamp"] else ""
+    )
+
+    # Reassign IDs to maintain sequential order after sorting
+    for idx, interaction in enumerate(sorted_interactions, 1):
+        interaction["id"] = str(idx)
+
+    return {"workflow": sorted_interactions}

ragaai_catalyst/tracers/exporters/ragaai_trace_exporter.py

@@ -3,13 +3,13 @@ import json
 import tempfile
 from opentelemetry.sdk.trace.export import SpanExporter, SpanExportResult
 import logging
-from datetime import datetime
 from dataclasses import asdict
 from ragaai_catalyst.tracers.utils.trace_json_converter import convert_json_format
 from ragaai_catalyst.tracers.agentic_tracing.tracers.base import TracerJSONEncoder
 from ragaai_catalyst.tracers.agentic_tracing.utils.system_monitor import SystemMonitor
 from ragaai_catalyst.tracers.agentic_tracing.upload.trace_uploader import submit_upload_task
 from ragaai_catalyst.tracers.agentic_tracing.utils.zip_list_of_unique_files import zip_list_of_unique_files
+from ragaai_catalyst.tracers.agentic_tracing.utils.trace_utils import format_interactions
 
 
 logger = logging.getLogger("RagaAICatalyst")
@@ -77,8 +77,9 @@ class RAGATraceExporter(SpanExporter):
 
     def prepare_trace(self, spans, trace_id):
         try:
-            ragaai_trace = convert_json_format(spans, self.custom_model_cost)            
-            ragaai_trace["workflow"] = []
+            ragaai_trace = convert_json_format(spans, self.custom_model_cost)   
+            interactions = format_interactions(ragaai_trace)         
+            ragaai_trace["workflow"] = interactions['workflow']
 
             # Add source code hash
             hash_id, zip_path = zip_list_of_unique_files(
@@ -111,9 +112,7 @@ class RAGATraceExporter(SpanExporter):
     def upload_trace(self, ragaai_trace_details, trace_id):
         filepath = ragaai_trace_details['trace_file_path']
         hash_id = ragaai_trace_details['hash_id']
-        zip_path = ragaai_trace_details['code_zip_path']
-
-        
+        zip_path = ragaai_trace_details['code_zip_path']  
 
         self.upload_task_id = submit_upload_task(
                 filepath=filepath,

ragaai_catalyst/tracers/tracer.py

@@ -1,4 +1,3 @@
-from audioop import add
 import os
 import uuid
 import datetime
@@ -37,6 +36,9 @@ from ragaai_catalyst.tracers.exporters.ragaai_trace_exporter import RAGATraceExp
 from ragaai_catalyst.tracers.agentic_tracing.utils.file_name_tracker import TrackName
 
 logger = logging.getLogger(__name__)
+logging_level = (
+    logger.setLevel(logging.DEBUG) if os.getenv("DEBUG") == "1" else logging.INFO
+)
 
 class Tracer(AgenticTracing):
     NUM_PROJECTS = 99999
@@ -90,7 +92,7 @@ class Tracer(AgenticTracing):
 
         # take care of auto_instrumentation
         if isinstance(auto_instrumentation, bool):
-            if tracer_type == "agentic/llamaindex":
+            if tracer_type.startswith("agentic/"):
                 auto_instrumentation = {
                     "llm": False,
                     "tool": False,
@@ -184,30 +186,148 @@ class Tracer(AgenticTracing):
         elif tracer_type == "llamaindex":
             self._upload_task = None
             self.llamaindex_tracer = None
-        elif tracer_type == "agentic/llamaindex":
-            from opentelemetry.sdk import trace as trace_sdk
-            from opentelemetry.sdk.trace.export import SimpleSpanProcessor 
-            from openinference.instrumentation.llama_index import LlamaIndexInstrumentor 
-            from ragaai_catalyst.tracers.exporters.dynamic_trace_exporter import DynamicTraceExporter
-
-            # Get the code_files
-            self.file_tracker.trace_main_file()
-            list_of_unique_files = self.file_tracker.get_unique_files()
-
-            # Create a dynamic exporter that allows property updates
-            self.dynamic_exporter = DynamicTraceExporter(
-                files_to_zip=list_of_unique_files,
-                project_name=self.project_name,
-                project_id=self.project_id,
-                dataset_name=self.dataset_name,
-                user_details=self.user_details,
-                base_url=self.base_url,
-                custom_model_cost=self.model_custom_cost
-            )
+        # Handle agentic tracers
+        elif tracer_type == "agentic" or tracer_type.startswith("agentic/"):
+            
+            # Setup instrumentors based on tracer type
+            instrumentors = []
+
+            # Add LLM Instrumentors
+            if tracer_type in ['agentic/crewai']:
+                try:
+                    from openinference.instrumentation.vertexai import VertexAIInstrumentor
+                    instrumentors.append((VertexAIInstrumentor, []))
+                except (ImportError, ModuleNotFoundError):
+                    logger.debug("VertexAI not available in environment")
+                try:
+                    from openinference.instrumentation.anthropic import AnthropicInstrumentor
+                    instrumentors.append((AnthropicInstrumentor, []))
+                except (ImportError, ModuleNotFoundError):
+                    logger.debug("Anthropic not available in environment")
+                try:
+                    from openinference.instrumentation.groq import GroqInstrumentor
+                    instrumentors.append((GroqInstrumentor, []))
+                except (ImportError, ModuleNotFoundError):
+                    logger.debug("Groq not available in environment")
+                try:
+                    from openinference.instrumentation.litellm import LiteLLMInstrumentor
+                    instrumentors.append((LiteLLMInstrumentor, []))
+                except (ImportError, ModuleNotFoundError):
+                    logger.debug("LiteLLM not available in environment")
+                try:
+                    from openinference.instrumentation.mistralai import MistralAIInstrumentor
+                    instrumentors.append((MistralAIInstrumentor, []))
+                except (ImportError, ModuleNotFoundError):
+                    logger.debug("MistralAI not available in environment")
+                try:
+                    from openinference.instrumentation.openai import OpenAIInstrumentor
+                    instrumentors.append((OpenAIInstrumentor, []))
+                except (ImportError, ModuleNotFoundError):
+                    logger.debug("OpenAI not available in environment")
+                try:
+                    from openinference.instrumentation.bedrock import BedrockInstrumentor
+                    instrumentors.append((BedrockInstrumentor, []))
+                except (ImportError, ModuleNotFoundError):
+                    logger.debug("Bedrock not available in environment")
+            
+            # If tracer_type is just "agentic", try to instrument all available packages
+            if tracer_type == "agentic":
+                logger.info("Attempting to instrument all available agentic packages")
+                
+                # Try to import and add all known instrumentors
+                try:
+                    # LlamaIndex
+                    try:
+                        from openinference.instrumentation.llama_index import LlamaIndexInstrumentor
+                        instrumentors.append((LlamaIndexInstrumentor, []))
+                        logger.info("Instrumenting LlamaIndex...")
+                    except (ImportError, ModuleNotFoundError):
+                        logger.debug("LlamaIndex not available in environment")
+                    
+                    # LangChain
+                    try:
+                        from openinference.instrumentation.langchain import LangChainInstrumentor
+                        instrumentors.append((LangChainInstrumentor, []))
+                        logger.info("Instrumenting LangChain...")
+                    except (ImportError, ModuleNotFoundError):
+                        logger.debug("LangChain not available in environment")
+                    
+                    # CrewAI
+                    try:
+                        from openinference.instrumentation.crewai import CrewAIInstrumentor
+                        instrumentors.append((CrewAIInstrumentor, []))
+                        logger.info("Instrumenting CrewAI...")
+                    except (ImportError, ModuleNotFoundError):
+                        logger.debug("CrewAI not available in environment")
+                    
+                    # Haystack
+                    try:
+                        from openinference.instrumentation.haystack import HaystackInstrumentor
+                        instrumentors.append((HaystackInstrumentor, []))
+                        logger.info("Instrumenting Haystack...")
+                    except (ImportError, ModuleNotFoundError):
+                        logger.debug("Haystack not available in environment")
+                    
+                    # AutoGen
+                    try:
+                        from openinference.instrumentation.autogen import AutogenInstrumentor
+                        instrumentors.append((AutogenInstrumentor, []))
+                        logger.info("Instrumenting AutoGen...")
+                    except (ImportError, ModuleNotFoundError):
+                        logger.debug("AutoGen not available in environment")
+                    
+                    # Smolagents
+                    try:
+                        from openinference.instrumentation.smolagents import SmolagentsInstrumentor
+                        instrumentors.append((SmolagentsInstrumentor, []))
+                        logger.info("Instrumenting Smolagents...")
+                    except (ImportError, ModuleNotFoundError):
+                        logger.debug("Smolagents not available in environment")
+                    
+                    if not instrumentors:
+                        logger.warning("No agentic packages found in environment to instrument")
+                        self._upload_task = None
+                        return
+                    
+                except Exception as e:
+                    logger.error(f"Error during auto-instrumentation: {str(e)}")
+                    self._upload_task = None
+                    return
+            
+            # Handle specific framework instrumentation
+            elif tracer_type == "agentic/llamaindex":
+                from openinference.instrumentation.llama_index import LlamaIndexInstrumentor
+                instrumentors += [(LlamaIndexInstrumentor, [])] 
+            
+            elif tracer_type == "agentic/langchain" or tracer_type == "agentic/langgraph":
+                from openinference.instrumentation.langchain import LangChainInstrumentor
+                instrumentors += [(LangChainInstrumentor, [])]
+            
+            elif tracer_type == "agentic/crewai":
+                from openinference.instrumentation.crewai import CrewAIInstrumentor
+                from openinference.instrumentation.langchain import LangChainInstrumentor
+                instrumentors += [(CrewAIInstrumentor, []), (LangChainInstrumentor, [])]
+            
+            elif tracer_type == "agentic/haystack":
+                from openinference.instrumentation.haystack import HaystackInstrumentor
+                instrumentors += [(HaystackInstrumentor, [])]
             
-            tracer_provider = trace_sdk.TracerProvider()
-            tracer_provider.add_span_processor(SimpleSpanProcessor(self.dynamic_exporter))
-            LlamaIndexInstrumentor().instrument(tracer_provider=tracer_provider)
+            elif tracer_type == "agentic/autogen":
+                from openinference.instrumentation.autogen import AutogenInstrumentor
+                instrumentors += [(AutogenInstrumentor, [])]
+            
+            elif tracer_type == "agentic/smolagents":
+                from openinference.instrumentation.smolagents import SmolagentsInstrumentor
+                instrumentors += [(SmolagentsInstrumentor, [])]
+            
+            else:
+                # Unknown agentic tracer type
+                logger.warning(f"Unknown agentic tracer type: {tracer_type}")
+                self._upload_task = None
+                return
+                
+            # Common setup for all agentic tracers
+            self._setup_agentic_tracer(instrumentors)
         else:
             self._upload_task = None
             # raise ValueError (f"Currently supported tracer types are 'langchain' and 'llamaindex'.")
@@ -576,12 +696,13 @@ class Tracer(AgenticTracing):
                 - dataset_name: Dataset name
                 - user_details: User details
                 - base_url: Base URL for API
+                - custom_model_cost: Dictionary of custom model costs
                 
         Raises:
-            AttributeError: If the tracer_type is not 'agentic/llamaindex' or if the dynamic_exporter is not initialized.
+            AttributeError: If the tracer_type is not an agentic tracer or if the dynamic_exporter is not initialized.
         """
-        if self.tracer_type != "agentic/llamaindex" or not hasattr(self, "dynamic_exporter"):
-            raise AttributeError("Dynamic exporter is only available for 'agentic/llamaindex' tracer type")
+        if not self.tracer_type.startswith("agentic/") or not hasattr(self, "dynamic_exporter"):
+            raise AttributeError("This method is only available for agentic tracers with a dynamic exporter.")
             
         for key, value in kwargs.items():
             if hasattr(self.dynamic_exporter, key):
@@ -590,6 +711,40 @@ class Tracer(AgenticTracing):
             else:
                 logger.warning(f"Dynamic exporter has no attribute '{key}'")
                 
+    def _setup_agentic_tracer(self, instrumentors):
+        """
+        Common setup for all agentic tracers.
+        
+        Args:
+            instrumentors (list): List of tuples (instrumentor_class, args) to be instrumented
+        """
+        from opentelemetry.sdk import trace as trace_sdk
+        from opentelemetry.sdk.trace.export import SimpleSpanProcessor
+        from ragaai_catalyst.tracers.exporters.dynamic_trace_exporter import DynamicTraceExporter
+        
+        # Get the code_files
+        self.file_tracker.trace_main_file()
+        list_of_unique_files = self.file_tracker.get_unique_files()
+
+        # Create a dynamic exporter that allows property updates
+        self.dynamic_exporter = DynamicTraceExporter(
+            files_to_zip=list_of_unique_files,
+            project_name=self.project_name,
+            project_id=self.project_id,
+            dataset_name=self.dataset_name,
+            user_details=self.user_details,
+            base_url=self.base_url,
+            custom_model_cost=self.model_custom_cost
+        )
+        
+        # Set up tracer provider
+        tracer_provider = trace_sdk.TracerProvider()
+        tracer_provider.add_span_processor(SimpleSpanProcessor(self.dynamic_exporter))
+        
+        # Instrument all specified instrumentors
+        for instrumentor_class, args in instrumentors:
+            instrumentor_class().instrument(tracer_provider=tracer_provider, *args)
+            
     def update_file_list(self):
         """
         Update the file list in the dynamic exporter with the latest tracked files.
@@ -598,8 +753,8 @@ class Tracer(AgenticTracing):
         Raises:
             AttributeError: If the tracer_type is not 'agentic/llamaindex' or if the dynamic_exporter is not initialized.
         """
-        if self.tracer_type != "agentic/llamaindex" or not hasattr(self, "dynamic_exporter"):
-            raise AttributeError("Dynamic exporter is only available for 'agentic/llamaindex' tracer type")
+        if not self.tracer_type.startswith("agentic/") or not hasattr(self, "dynamic_exporter"):
+            raise AttributeError("This method is only available for agentic tracers with a dynamic exporter.")
             
         # Get the latest list of unique files
         list_of_unique_files = self.file_tracker.get_unique_files()

ragaai_catalyst/tracers/utils/trace_json_converter.py

@@ -1,7 +1,7 @@
 import json
 import sys
 from datetime import datetime
-from typing import final
+from typing import final, List, Dict, Any, Optional
 import pytz
 import uuid
 from ragaai_catalyst.tracers.agentic_tracing.utils.llm_utils import calculate_llm_cost, get_model_cost
@@ -35,14 +35,29 @@ def get_uuid(name):
     """Generate a random UUID (not based on name)."""
     return str(uuid.uuid5(uuid.NAMESPACE_DNS, name))
 
+def get_ordered_family(parent_children_mapping: Dict[str, Any]) -> List[str]:
+    def ordering_function(parent_id: str, ordered_family: List[str]):
+        children = parent_children_mapping.get(parent_id, [])
+        parent_child_ids =[child['id'] for child in children if child['id'] in parent_children_mapping]
+        for child_id in parent_child_ids:
+            if child_id not in ordered_family:
+                ordered_family.append(child_id)
+                ordering_function(child_id, ordered_family)
+    ordered_family = [None]
+    ordering_function(None, ordered_family)
+    return reversed(ordered_family)
+
 def get_spans(input_trace, custom_model_cost):
-    data=[]
+    span_map = {}
+    parent_children_mapping = {}
     span_type_mapping={"AGENT":"agent","LLM":"llm","TOOL":"tool"}
     span_name_occurrence = {}
     for span in input_trace:
         final_span = {}
         span_type=span_type_mapping.get(span["attributes"]["openinference.span.kind"],"custom")
-        final_span["id"] = span["context"]["span_id"]
+        span_id = span["context"]["span_id"]
+        parent_id = span["parent_id"]
+        final_span["id"] = span_id
         if span["name"] not in span_name_occurrence:
             span_name_occurrence[span['name']]=0
         else:
@@ -53,7 +68,7 @@ def get_spans(input_trace, custom_model_cost):
         final_span["type"] = span_type
         final_span["start_time"] = convert_time_format(span['start_time'])
         final_span["end_time"] = convert_time_format(span['end_time'])
-        final_span["parent_id"] = span["parent_id"]
+        final_span["parent_id"] = parent_id
         final_span["extra_info"] = None
         '''Handle Error if any'''
         if span["status"]["status_code"].lower() == "error":
@@ -82,6 +97,7 @@ def get_spans(input_trace, custom_model_cost):
                     final_span["data"]["output"] = span["attributes"]["output.value"]
             else:
                 final_span["data"]["output"] = ""
+            final_span["data"]['children'] = []
         
         elif span_type=="tool":
             available_fields = list(span['attributes'].keys())
@@ -189,7 +205,23 @@ def get_spans(input_trace, custom_model_cost):
                         "total_tokens": final_span["info"]["tokens"]["total_tokens"]
                     }
                     final_span["info"]["cost"] = calculate_llm_cost(token_usage=token_usage, model_name=model_name, model_costs=model_costs, model_custom_cost=custom_model_cost) 
-        data.append(final_span)
+        span_map[span_id] = final_span
+        if parent_id not in parent_children_mapping:
+            parent_children_mapping[parent_id] = []
+        parent_children_mapping[parent_id].append(final_span)
+    ordered_family = get_ordered_family(parent_children_mapping)
+    data = []
+    for parent_id in ordered_family:
+        children = parent_children_mapping[parent_id]
+        if parent_id in span_map:
+            parent_type = span_map[parent_id]["type"]
+            if parent_type == 'agent':
+                span_map[parent_id]['data']["children"] = children
+            else:
+                grand_parent_id = span_map[parent_id]["parent_id"]
+                parent_children_mapping[grand_parent_id].extend(children)
+        else:
+            data = children
     return data
 
 def convert_json_format(input_trace, custom_model_cost):

{ragaai_catalyst-2.1.5.1b2.dist-info → ragaai_catalyst-2.1.6b0.dist-info}/METADATA

@@ -1,29 +1,18 @@
 Metadata-Version: 2.2
 Name: ragaai_catalyst
-Version: 2.1.5.1b2
+Version: 2.1.6b0
 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>
 Requires-Python: <3.13,>=3.9
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: aiohttp>=3.10.2
-Requires-Dist: opentelemetry-api==1.25.0
-Requires-Dist: opentelemetry-sdk==1.25.0
-Requires-Dist: opentelemetry-exporter-otlp-proto-grpc==1.25.0
-Requires-Dist: opentelemetry-instrumentation==0.46b0
-Requires-Dist: opentelemetry-instrumentation-fastapi==0.46b0
-Requires-Dist: opentelemetry-instrumentation-asgi==0.46b0
-Requires-Dist: opentelemetry-semantic-conventions==0.46b0
-Requires-Dist: opentelemetry-util-http==0.46b0
-Requires-Dist: opentelemetry-instrumentation-langchain~=0.24.0
-Requires-Dist: opentelemetry-instrumentation-openai~=0.24.0
 Requires-Dist: langchain-core>=0.2.11
 Requires-Dist: langchain>=0.2.11
 Requires-Dist: openai>=1.57.0
 Requires-Dist: pandas
 Requires-Dist: groq>=0.11.0
-Requires-Dist: PyPDF2>=3.0.1
-Requires-Dist: google-generativeai>=0.8.2
+Requires-Dist: pypdf>=5.3.1
 Requires-Dist: google-genai>=1.3.0
 Requires-Dist: Markdown>=3.7
 Requires-Dist: litellm==1.51.1

{ragaai_catalyst-2.1.5.1b2.dist-info → ragaai_catalyst-2.1.6b0.dist-info}/RECORD

@@ -10,7 +10,7 @@ ragaai_catalyst/prompt_manager.py,sha256=W8ypramzOprrJ7-22d5vkBXIuIQ8v9XAzKDGxKs
 ragaai_catalyst/proxy_call.py,sha256=CHxldeceZUaLU-to_hs_Kf1z_b2vHMssLS_cOBedu78,5499
 ragaai_catalyst/ragaai_catalyst.py,sha256=1FaeK_VZpJLQ1ZqEWpMyI8J8M2MI0abLLLDFWY9W-4A,19580
 ragaai_catalyst/redteaming_old.py,sha256=W2d89Ok8W-C8g7TBM3fDIFLof3q9FuYSr0jcryH2XQo,7097
-ragaai_catalyst/synthetic_data_generation.py,sha256=oWxV36wewwrggxXgvOZtzf-M5IOYalP1h5XjF6IOyY8,37597
+ragaai_catalyst/synthetic_data_generation.py,sha256=RsaT2sJ4MxvwYU0t4tOTm9lAcsJJEPR3Z_YhG-Lo39g,37880
 ragaai_catalyst/utils.py,sha256=TlhEFwLyRU690HvANbyoRycR3nQ67lxVUQoUOfTPYQ0,3772
 ragaai_catalyst/redteaming/__init__.py,sha256=TJdvZpaZGFsg9qKONdjTosSVLZGadYFpHG6KE0xapKU,155
 ragaai_catalyst/redteaming/evaluator.py,sha256=C50SAc3RsR7PZnz-VQ7wQfDpiVEb7T3W3KV4Lj0tWYE,4599
@@ -31,7 +31,7 @@ ragaai_catalyst/tracers/distributed.py,sha256=MwlBwIxCAng-OI-7Ove_rkE1mTLeuW4Jw-
 ragaai_catalyst/tracers/langchain_callback.py,sha256=CB75zzG3-DkYTELj0vI1MOHQTY0MuQJfoHIXz9Cl8S8,34568
 ragaai_catalyst/tracers/llamaindex_callback.py,sha256=ZY0BJrrlz-P9Mg2dX-ZkVKG3gSvzwqBtk7JL_05MiYA,14028
 ragaai_catalyst/tracers/llamaindex_instrumentation.py,sha256=Ys_jLkvVqo12bKgXDmkp4TxJu9HkBATrFE8cIcTYxWw,14329
-ragaai_catalyst/tracers/tracer.py,sha256=oaag7-VdUufR5LygnKcUgjTvlAEcxToVxNYkQCWEhkg,27827
+ragaai_catalyst/tracers/tracer.py,sha256=NFrDbko4xw7QYEWUfi98LyKlxROUyAbDktf0y3DCARg,35996
 ragaai_catalyst/tracers/upload_traces.py,sha256=OKsc-Obf8bJvKBprt3dqj8GQQNkoX3kT_t8TBDi9YDQ,5670
 ragaai_catalyst/tracers/agentic_tracing/README.md,sha256=X4QwLb7-Jg7GQMIXj-SerZIgDETfw-7VgYlczOR8ZeQ,4508
 ragaai_catalyst/tracers/agentic_tracing/__init__.py,sha256=yf6SKvOPSpH-9LiKaoLKXwqj5sez8F_5wkOb91yp0oE,260
@@ -54,7 +54,7 @@ ragaai_catalyst/tracers/agentic_tracing/tracers/network_tracer.py,sha256=m8CxYkl
 ragaai_catalyst/tracers/agentic_tracing/tracers/tool_tracer.py,sha256=xxrliKPfdfbIZRZqMnUewsaTD8_Hv0dbuoBivNZGD4U,21674
 ragaai_catalyst/tracers/agentic_tracing/tracers/user_interaction_tracer.py,sha256=bhSUhNQCuJXKjgJAXhjKEYjnHMpYN90FSZdR84fNIKU,4614
 ragaai_catalyst/tracers/agentic_tracing/upload/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-ragaai_catalyst/tracers/agentic_tracing/upload/trace_uploader.py,sha256=Buk0OXjdkku0tuuFzGeqKRtwSeIBe3LpA1oa14qS7v4,12380
+ragaai_catalyst/tracers/agentic_tracing/upload/trace_uploader.py,sha256=UnGpcMpRbntUrYsIU11r-gMHtzNkDGSGCbepiL_XTFA,12379
 ragaai_catalyst/tracers/agentic_tracing/upload/upload_agentic_traces.py,sha256=icycLgfA0734xxoM1rTMG_iIrI3iM94th8RQggJ7sSw,8541
 ragaai_catalyst/tracers/agentic_tracing/upload/upload_code.py,sha256=aw_eHhUYRbR_9IbIkNjYb7NOsmETD3k1p4a6gxaGI7Q,6462
 ragaai_catalyst/tracers/agentic_tracing/upload/upload_local_metric.py,sha256=m1O8lKpxKwtHofXLW3fTHX5yfqDW5GxoveARlg5cTw4,2571
@@ -70,14 +70,14 @@ ragaai_catalyst/tracers/agentic_tracing/utils/model_costs.json,sha256=2tzGw_cKCT
 ragaai_catalyst/tracers/agentic_tracing/utils/span_attributes.py,sha256=qmODERcFZhc8MX24boFCXkkh6sJ-vZngRHPvxhyWFeE,4347
 ragaai_catalyst/tracers/agentic_tracing/utils/supported_llm_provider.toml,sha256=LvFDivDIE96Zasp-fgDEqUJ5GEQZUawQucR3aOcSUTY,926
 ragaai_catalyst/tracers/agentic_tracing/utils/system_monitor.py,sha256=H8WNsk4v_5T6OUw4TFOzlDLjQhJwjh1nAMyMAoqMEi4,6946
-ragaai_catalyst/tracers/agentic_tracing/utils/trace_utils.py,sha256=go7FVnofviATDph-j8sk2juv09CGSRt1Vq4U868Fhd8,2259
+ragaai_catalyst/tracers/agentic_tracing/utils/trace_utils.py,sha256=rssHolDvKxZ9V6-4VTFAqC65o6-CG924hA0CnG3smSc,15902
 ragaai_catalyst/tracers/agentic_tracing/utils/unique_decorator.py,sha256=G027toV-Km20JjKrc-Y_PilQ8ABEKrBvvzgLTnqVg7I,5819
 ragaai_catalyst/tracers/agentic_tracing/utils/zip_list_of_unique_files.py,sha256=4TeCGsFF26249fV6dJHLTZDrRa93SG9oer4rudoF8Y4,19443
 ragaai_catalyst/tracers/exporters/__init__.py,sha256=wQbaqyeIjVZxYprHCKZ9BeiqxeXYBKjzEgP79LWNxCU,293
 ragaai_catalyst/tracers/exporters/dynamic_trace_exporter.py,sha256=w9U8UTxvTbGTDUoMtsgy2BsdpYp-APTKFdGV4o5JPaM,5051
 ragaai_catalyst/tracers/exporters/file_span_exporter.py,sha256=RgGteu-NVGprXKkynvyIO5yOjpbtA41R3W_NzCjnkwE,6445
 ragaai_catalyst/tracers/exporters/raga_exporter.py,sha256=6xvjWXyh8XPkHKSLLmAZUQSvwuyY17ov8pv2VdfI0qA,17875
-ragaai_catalyst/tracers/exporters/ragaai_trace_exporter.py,sha256=s8zIUMrUKhtGrg-32XZnlJPKXWSyHo_WiJ1DoTcHVRg,5170
+ragaai_catalyst/tracers/exporters/ragaai_trace_exporter.py,sha256=HZG1UjcipgQOHkeqQHVGxenIab2mHqcVmWqtOXlMt6Q,5305
 ragaai_catalyst/tracers/instrumentators/__init__.py,sha256=FgnMQupoRTzmVsG9YKsLQera2Pfs-AluZv8CxwavoyQ,253
 ragaai_catalyst/tracers/instrumentators/langchain.py,sha256=yMN0qVF0pUVk6R5M1vJoUXezDo1ejs4klCFRlE8x4vE,574
 ragaai_catalyst/tracers/instrumentators/llamaindex.py,sha256=SMrRlR4xM7k9HK43hakE8rkrWHxMlmtmWD-AX6TeByc,416
@@ -88,10 +88,10 @@ ragaai_catalyst/tracers/utils/convert_llama_instru_callback.py,sha256=8qLo7x4Zsn
 ragaai_catalyst/tracers/utils/extraction_logic_llama_index.py,sha256=ZhPs0YhVtB82-Pq9o1BvCinKE_WPvVxPTEcZjlJbFYM,2371
 ragaai_catalyst/tracers/utils/langchain_tracer_extraction_logic.py,sha256=XS2_x2qneqEx9oAighLg-LRiueWcESLwIC2r7eJT-Ww,3117
 ragaai_catalyst/tracers/utils/model_prices_and_context_window_backup.json,sha256=C3uwkibJ08C9sOX-54kulZYmJlIpZ-SQpfE6HNGrjbM,343502
-ragaai_catalyst/tracers/utils/trace_json_converter.py,sha256=qXSYKr4JMUpGQsB3mnr9_2qH6FqzUhCynNqlDp1IWTs,12440
+ragaai_catalyst/tracers/utils/trace_json_converter.py,sha256=06oTKZHtKL9ylBybpYNU8AfT9xIVMekUBOhlUnRvzB8,13969
 ragaai_catalyst/tracers/utils/utils.py,sha256=ViygfJ7vZ7U0CTSA1lbxVloHp4NSlmfDzBRNCJuMhis,2374
-ragaai_catalyst-2.1.5.1b2.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-ragaai_catalyst-2.1.5.1b2.dist-info/METADATA,sha256=Nv0jgHG5lZLvef0tdbH7msv7Wb2nkPVEH1GgK_JH-xQ,22057
-ragaai_catalyst-2.1.5.1b2.dist-info/WHEEL,sha256=52BFRY2Up02UkjOa29eZOS2VxUrpPORXg1pkohGGUS8,91
-ragaai_catalyst-2.1.5.1b2.dist-info/top_level.txt,sha256=HpgsdRgEJMk8nqrU6qdCYk3di7MJkDL0B19lkc7dLfM,16
-ragaai_catalyst-2.1.5.1b2.dist-info/RECORD,,
+ragaai_catalyst-2.1.6b0.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+ragaai_catalyst-2.1.6b0.dist-info/METADATA,sha256=9jXmItgYw2N3g013dK16qpjvA8jGq_Q_jza3o0lqJi0,21468
+ragaai_catalyst-2.1.6b0.dist-info/WHEEL,sha256=beeZ86-EfXScwlR_HKu4SllMC9wUEj_8Z_4FJ3egI2w,91
+ragaai_catalyst-2.1.6b0.dist-info/top_level.txt,sha256=HpgsdRgEJMk8nqrU6qdCYk3di7MJkDL0B19lkc7dLfM,16
+ragaai_catalyst-2.1.6b0.dist-info/RECORD,,

{ragaai_catalyst-2.1.5.1b2.dist-info → ragaai_catalyst-2.1.6b0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (76.0.0)
+Generator: setuptools (76.1.0)
 Root-Is-Purelib: true
 Tag: py3-none-any