ragaai-catalyst 2.1.5b35__py3-none-any.whl → 2.1.5b37__py3-none-any.whl

ragaai_catalyst/tracers/exporters/__init__.py

@@ -1,5 +1,7 @@
 from .file_span_exporter import FileSpanExporter
 from .raga_exporter import RagaExporter
+from .ragaai_trace_exporter import RAGATraceExporter
+from .dynamic_trace_exporter import DynamicTraceExporter
 
 
-__all__ = ["FileSpanExporter", "RagaExporter"]
+__all__ = ["FileSpanExporter", "RagaExporter", "RAGATraceExporter", "DynamicTraceExporter"]

ragaai_catalyst/tracers/exporters/dynamic_trace_exporter.py

@@ -0,0 +1,145 @@
+"""
+Dynamic Trace Exporter - A wrapper for RAGATraceExporter that allows dynamic updates to properties.
+"""
+import logging
+from opentelemetry.sdk.trace.export import SpanExporter, SpanExportResult
+from ragaai_catalyst.tracers.exporters.ragaai_trace_exporter import RAGATraceExporter
+
+logger = logging.getLogger("RagaAICatalyst")
+
+class DynamicTraceExporter(SpanExporter):
+    """
+    A wrapper around RAGATraceExporter that allows dynamic updates to properties.
+    This exporter forwards all calls to the underlying RAGATraceExporter but allows
+    certain properties to be updated dynamically during execution.
+    """
+    
+    def __init__(self, files_to_zip, project_name, project_id, dataset_name, user_details, base_url, custom_model_cost):
+        """
+        Initialize the DynamicTraceExporter.
+        
+        Args:
+            files_to_zip: List of files to zip
+            project_name: Project name
+            project_id: Project ID
+            dataset_name: Dataset name
+            user_details: User details
+            base_url: Base URL for API
+        """
+        self._exporter = RAGATraceExporter(
+            files_to_zip=files_to_zip,
+            project_name=project_name,
+            project_id=project_id,
+            dataset_name=dataset_name,
+            user_details=user_details,
+            base_url=base_url,
+            custom_model_cost=custom_model_cost
+        )
+        
+        # Store the initial values
+        self._files_to_zip = files_to_zip
+        self._project_name = project_name
+        self._project_id = project_id
+        self._dataset_name = dataset_name
+        self._user_details = user_details
+        self._base_url = base_url,
+        self._custom_model_cost = custom_model_cost
+
+    
+    def export(self, spans):
+        """
+        Export spans by forwarding to the underlying exporter.
+        Before exporting, update the exporter's properties with the current values.
+        
+        Args:
+            spans: Spans to export
+            
+        Returns:
+            SpanExportResult: Result of the export operation
+        """
+        # Update the exporter's properties
+        self._update_exporter_properties()
+        
+        # Forward the call to the underlying exporter
+        return self._exporter.export(spans)
+    
+    def shutdown(self):
+        """
+        Shutdown the exporter by forwarding to the underlying exporter.
+        Before shutting down, update the exporter's properties with the current values.
+        """
+        # Update the exporter's properties
+        self._update_exporter_properties()
+        
+        # Forward the call to the underlying exporter
+        return self._exporter.shutdown()
+    
+    def _update_exporter_properties(self):
+        """
+        Update the underlying exporter's properties with the current values.
+        """
+        self._exporter.files_to_zip = self._files_to_zip
+        self._exporter.project_name = self._project_name
+        self._exporter.project_id = self._project_id
+        self._exporter.dataset_name = self._dataset_name
+        self._exporter.user_details = self._user_details
+        self._exporter.base_url = self._base_url
+        self._exporter.custom_model_cost = self._custom_model_cost
+    
+    # Getter and setter methods for dynamic properties
+    
+    @property
+    def files_to_zip(self):
+        return self._files_to_zip
+    
+    @files_to_zip.setter
+    def files_to_zip(self, value):
+        self._files_to_zip = value
+    
+    @property
+    def project_name(self):
+        return self._project_name
+    
+    @project_name.setter
+    def project_name(self, value):
+        self._project_name = value
+    
+    @property
+    def project_id(self):
+        return self._project_id
+    
+    @project_id.setter
+    def project_id(self, value):
+        self._project_id = value
+    
+    @property
+    def dataset_name(self):
+        return self._dataset_name
+    
+    @dataset_name.setter
+    def dataset_name(self, value):
+        self._dataset_name = value
+    
+    @property
+    def user_details(self):
+        return self._user_details
+    
+    @user_details.setter
+    def user_details(self, value):
+        self._user_details = value
+    
+    @property
+    def base_url(self):
+        return self._base_url
+    
+    @base_url.setter
+    def base_url(self, value):
+        self._base_url = value
+
+    @property
+    def custom_model_cost(self):
+        return self._custom_model_cost
+    
+    @custom_model_cost.setter
+    def custom_model_cost(self, value):
+        self._custom_model_cost = value

ragaai_catalyst/tracers/exporters/ragaai_trace_exporter.py

@@ -0,0 +1,121 @@
+import os
+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
+
+
+logger = logging.getLogger("RagaAICatalyst")
+logging_level = (
+    logger.setLevel(logging.DEBUG) if os.getenv("DEBUG") == "1" else logging.INFO
+)
+
+
+class RAGATraceExporter(SpanExporter):
+    def __init__(self, files_to_zip, project_name, project_id, dataset_name, user_details, base_url, custom_model_cost):
+        self.trace_spans = dict()
+        self.tmp_dir = tempfile.gettempdir()
+        self.files_to_zip = files_to_zip
+        self.project_name = project_name
+        self.project_id = project_id
+        self.dataset_name = dataset_name
+        self.user_details = user_details
+        self.base_url = base_url
+        self.custom_model_cost = custom_model_cost
+        self.system_monitor = SystemMonitor(dataset_name)
+
+    def export(self, spans):
+        for span in spans:
+            span_json = json.loads(span.to_json())
+            trace_id = span_json.get("context").get("trace_id")
+
+            if trace_id not in self.trace_spans:
+                self.trace_spans[trace_id] = list()
+
+            self.trace_spans[trace_id].append(span_json)
+
+            if span_json["parent_id"] is None:
+                trace = self.trace_spans[trace_id]
+                self.process_complete_trace(trace, trace_id)
+                del self.trace_spans[trace_id]
+
+        return SpanExportResult.SUCCESS
+
+    def shutdown(self):
+        # Process any remaining traces during shutdown
+        for trace_id, spans in self.trace_spans.items():
+            self.process_complete_trace(spans, trace_id)
+        self.trace_spans.clear()
+
+    def process_complete_trace(self, spans, trace_id):
+        # Convert the trace to ragaai trace format
+        try:
+            ragaai_trace_details = self.prepare_trace(spans, trace_id)
+        except Exception as e:
+            print(f"Error converting trace {trace_id}: {e}")
+        
+        # Upload the trace if upload_trace function is provided
+        try:
+            self.upload_trace(ragaai_trace_details, trace_id)
+        except Exception as e:
+            print(f"Error uploading trace {trace_id}: {e}")
+
+    def prepare_trace(self, spans, trace_id):
+        try:
+            ragaai_trace = convert_json_format(spans, self.custom_model_cost)            
+            ragaai_trace["workflow"] = []
+
+            # Add source code hash
+            hash_id, zip_path = zip_list_of_unique_files(
+                self.files_to_zip, output_dir=self.tmp_dir
+            )
+
+            ragaai_trace["metadata"]["system_info"] = asdict(self.system_monitor.get_system_info())
+            ragaai_trace["metadata"]["resources"] = asdict(self.system_monitor.get_resources())
+            ragaai_trace["metadata"]["system_info"]["source_code"] = hash_id
+
+            ragaai_trace["data"][0]["start_time"] = ragaai_trace["start_time"]
+            ragaai_trace["data"][0]["end_time"] = ragaai_trace["end_time"]
+
+            ragaai_trace["project_name"] = self.project_name
+            
+            # Save the trace_json 
+            trace_file_path = os.path.join(self.tmp_dir, f"{trace_id}.json")
+            with open(trace_file_path, "w") as file:
+                json.dump(ragaai_trace, file, cls=TracerJSONEncoder, indent=2)
+
+            return {
+                'trace_file_path': trace_file_path,
+                'code_zip_path': zip_path,
+                'hash_id': hash_id
+            }
+        except Exception as e:
+            logger.error(f"Error converting trace {trace_id}: {str(e)}")
+            return None
+
+    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']
+
+        
+
+        self.upload_task_id = submit_upload_task(
+                filepath=filepath,
+                hash_id=hash_id,
+                zip_path=zip_path,
+                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
+            )
+
+        logger.info(f"Submitted upload task with ID: {self.upload_task_id}")

ragaai_catalyst/tracers/tracer.py

@@ -31,13 +31,15 @@ from ragaai_catalyst.tracers.utils import get_unique_key
 # from ragaai_catalyst.tracers.llamaindex_callback import LlamaIndexTracer
 from ragaai_catalyst.tracers.llamaindex_instrumentation import LlamaIndexInstrumentationTracer
 from ragaai_catalyst import RagaAICatalyst
-from ragaai_catalyst.tracers.agentic_tracing import AgenticTracing, TrackName
+from ragaai_catalyst.tracers.agentic_tracing import AgenticTracing
 from ragaai_catalyst.tracers.agentic_tracing.tracers.llm_tracer import LLMTracerMixin
+from ragaai_catalyst.tracers.exporters.ragaai_trace_exporter import RAGATraceExporter
+from ragaai_catalyst.tracers.agentic_tracing.utils.file_name_tracker import TrackName
 
 logger = logging.getLogger(__name__)
 
 class Tracer(AgenticTracing):
-    NUM_PROJECTS = 100
+    NUM_PROJECTS = 99999
     TIMEOUT = 10
     def __init__(
         self,
@@ -88,7 +90,17 @@ class Tracer(AgenticTracing):
 
         # take care of auto_instrumentation
         if isinstance(auto_instrumentation, bool):
-            if auto_instrumentation:
+            if tracer_type == "agentic/llamaindex":
+                auto_instrumentation = {
+                    "llm": False,
+                    "tool": False,
+                    "agent": False,
+                    "user_interaction": False,
+                    "file_io": False,
+                    "network": False,
+                    "custom": False
+                }
+            elif auto_instrumentation:
                 auto_instrumentation = {
                     "llm": True,
                     "tool": True,
@@ -127,10 +139,11 @@ class Tracer(AgenticTracing):
         self.upload_timeout = upload_timeout
         self.base_url = f"{RagaAICatalyst.BASE_URL}"
         self.timeout = 30
-        self.num_projects = 100
+        self.num_projects = 99999
         self.start_time = datetime.datetime.now().astimezone().isoformat()
         self.model_cost_dict = model_cost
         self.user_context = ""  # Initialize user_context to store context from add_context
+        self.file_tracker = TrackName()
         
         try:
             response = requests.get(
@@ -171,7 +184,30 @@ 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
+            )
+            
+            tracer_provider = trace_sdk.TracerProvider()
+            tracer_provider.add_span_processor(SimpleSpanProcessor(self.dynamic_exporter))
+            LlamaIndexInstrumentor().instrument(tracer_provider=tracer_provider)
         else:
             self._upload_task = None
             # raise ValueError (f"Currently supported tracer types are 'langchain' and 'llamaindex'.")
@@ -206,30 +242,44 @@ class Tracer(AgenticTracing):
             "output_cost_per_token": float(cost_config["output_cost_per_million_token"]) /1000000
         }
 
-
-
     def set_dataset_name(self, dataset_name):
         """
         Reinitialize the Tracer with a new dataset name while keeping all other parameters the same.
+        If using agentic/llamaindex tracer with dynamic exporter, update the exporter's dataset_name property.
         
         Args:
             dataset_name (str): The new dataset name to set
         """
-        # Store current parameters
-        current_params = {
-            'project_name': self.project_name,
-            'tracer_type': self.tracer_type,
-            'pipeline': self.pipeline,
-            'metadata': self.metadata,
-            'description': self.description,
-            'upload_timeout': self.upload_timeout
-        }
-        
-        # Reinitialize self with new dataset_name and stored parameters
-        self.__init__(
-            dataset_name=dataset_name,
-            **current_params
-        )
+        # If we have a dynamic exporter, update its dataset_name property
+        if self.tracer_type == "agentic/llamaindex" and hasattr(self, "dynamic_exporter"):
+            # Update the dataset name in the dynamic exporter
+            self.dynamic_exporter.dataset_name = dataset_name
+            logger.debug(f"Updated dynamic exporter's dataset_name to {dataset_name}")
+            
+            # Update the instance variable
+            self.dataset_name = dataset_name
+            
+            # Update user_details with new dataset_name
+            self.user_details = self._pass_user_data()
+            
+            # Also update the user_details in the dynamic exporter
+            self.dynamic_exporter.user_details = self.user_details
+        else:
+            # Store current parameters
+            current_params = {
+                'project_name': self.project_name,
+                'tracer_type': self.tracer_type,
+                'pipeline': self.pipeline,
+                'metadata': self.metadata,
+                'description': self.description,
+                'upload_timeout': self.upload_timeout
+            }
+            
+            # Reinitialize self with new dataset_name and stored parameters
+            self.__init__(
+                dataset_name=dataset_name,
+                **current_params
+            )
 
     def _improve_metadata(self, metadata, tracer_type):
         if metadata is None:
@@ -375,7 +425,7 @@ class Tracer(AgenticTracing):
                          project_name=self.project_name,
                          project_id=self.project_id,
                          dataset_name=self.dataset_name,
-                         user_detail=user_detail,
+                         user_detail=self._pass_user_data(),
                          base_url=self.base_url
                          ).upload_traces(additional_metadata_keys=additional_metadata_dict)
             
@@ -514,6 +564,50 @@ class Tracer(AgenticTracing):
             }
         return user_detail
 
+    def update_dynamic_exporter(self, **kwargs):
+        """
+        Update the dynamic exporter's properties.
+        
+        Args:
+            **kwargs: Keyword arguments to update. Can include any of the following:
+                - files_to_zip: List of files to zip
+                - project_name: Project name
+                - project_id: Project ID
+                - dataset_name: Dataset name
+                - user_details: User details
+                - base_url: Base URL for API
+                
+        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")
+            
+        for key, value in kwargs.items():
+            if hasattr(self.dynamic_exporter, key):
+                setattr(self.dynamic_exporter, key, value)
+                logger.debug(f"Updated dynamic exporter's {key} to {value}")
+            else:
+                logger.warning(f"Dynamic exporter has no attribute '{key}'")
+                
+    def update_file_list(self):
+        """
+        Update the file list in the dynamic exporter with the latest tracked files.
+        This is useful when new files are added to the project during execution.
+        
+        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")
+            
+        # Get the latest list of unique files
+        list_of_unique_files = self.file_tracker.get_unique_files()
+        
+        # Update the dynamic exporter's files_to_zip property
+        self.dynamic_exporter.files_to_zip = list_of_unique_files
+        logger.debug(f"Updated dynamic exporter's files_to_zip with {len(list_of_unique_files)} files")
+    
     def add_context(self, context):
         """
         Add context information to the trace. This method is only supported for 'langchain' and 'llamaindex' tracer types.