Merge pull request #218 from raga-ai-hub/v2.1.7

v2.1.7.4

Author: kiranscaria

pyproject.toml

@@ -8,7 +8,7 @@ description = "RAGA AI CATALYST"
 readme = "README.md"
 requires-python = ">=3.10,<=3.13.2"
 # license = {file = "LICENSE"}
-version = "2.1.6.4"
+version = "2.1.7.4"
 authors = [
     {name = "Kiran Scaria", email = "kiran.scaria@raga.ai"},
     {name = "Kedar Gaikwad", email = "kedar.gaikwad@raga.ai"},

ragaai_catalyst/tracers/agentic_tracing/upload/trace_uploader.py

@@ -157,7 +157,7 @@ def process_upload(task_id: str, filepath: str, hash_id: str, zip_path: str,
                 )
                 logger.info(f"Trace metrics uploaded: {response}")
             except Exception as e:
-                logger.error(f"Error uploading trace metrics: {e}")
+                logger.error(f"Error uploading trace trace uploader metrics: {e}")
                 # Continue with other uploads
         else:
             logger.warning(f"Trace file {filepath} not found, skipping metrics upload")
@@ -364,4 +364,4 @@ def run_daemon():
     if args.daemon:
         logger.info("Daemon mode not needed in futures implementation")
     else:
-        logger.info("Interactive mode not needed in futures implementation")
+        logger.info("Interactive mode not needed in futures implementation")

ragaai_catalyst/tracers/exporters/ragaai_trace_exporter.py

@@ -89,15 +89,15 @@ def process_complete_trace(self, spans, trace_id):
         except Exception as e:
             print(f"Error converting trace {trace_id}: {e}")
             return  # Exit early if conversion fails
-            
+
         # Check if trace details are None (conversion failed)
         if ragaai_trace_details is None:
             logger.error(f"Cannot upload trace {trace_id}: conversion failed and returned None")
             return  # Exit early if conversion failed
 
         # Upload the trace if upload_trace function is provided
         try:
-            if self.post_processor!=None:
+            if self.post_processor!=None and self.tracer_type != "langchain":
                 ragaai_trace_details['trace_file_path'] = self.post_processor(ragaai_trace_details['trace_file_path'])
             if self.tracer_type == "langchain":
                 # Check if we're already in an event loop
@@ -106,18 +106,18 @@ def process_complete_trace(self, spans, trace_id):
                     if loop.is_running():
                         # We're in a running event loop (like in Colab/Jupyter)
                         # Create a future and run the coroutine
-                        future = asyncio.ensure_future(self.upload_rag_trace(ragaai_trace_details, additional_metadata, trace_id))
+                        future = asyncio.ensure_future(self.upload_rag_trace(ragaai_trace_details, additional_metadata, trace_id, self.post_processor))
                         # We don't wait for it to complete as this would block the event loop
                         logger.info(f"Scheduled async upload for trace {trace_id} in existing event loop")
                     else:
                         # No running event loop, use asyncio.run()
-                        asyncio.run(self.upload_rag_trace(ragaai_trace_details, additional_metadata, trace_id))
+                        asyncio.run(self.upload_rag_trace(ragaai_trace_details, additional_metadata, trace_id, self.post_processor))
                 except RuntimeError:
                     # No event loop exists, create one
-                    asyncio.run(self.upload_rag_trace(ragaai_trace_details, additional_metadata, trace_id))
+                    asyncio.run(self.upload_rag_trace(ragaai_trace_details, additional_metadata, trace_id, self.post_processor))
             else:
                 self.upload_trace(ragaai_trace_details, trace_id)
-        except Exception as e:
+        except Exception as e: 
             print(f"Error uploading trace {trace_id}: {e}")
 
     def prepare_trace(self, spans, trace_id):
@@ -206,13 +206,16 @@ def upload_trace(self, ragaai_trace_details, trace_id):
 
         logger.info(f"Submitted upload task with ID: {self.upload_task_id}")
 
-    async def upload_rag_trace(self, ragaai_trace, additional_metadata, trace_id):
+    async def upload_rag_trace(self, ragaai_trace, additional_metadata, trace_id, post_processor=None):
         try:
             ragaai_trace[0]['external_id'] = self.external_id
             trace_file_path = os.path.join(self.tmp_dir, f"{trace_id}.json")
             with open(trace_file_path, 'w') as f:
                 json.dump(ragaai_trace, f, indent=2)
             logger.info(f"Trace file saved at {trace_file_path}")
+            if self.post_processor!=None:
+                trace_file_path = self.post_processor(trace_file_path)
+                logger.info(f"After post processing Trace file saved at {trace_file_path}")
 
             # Create a ThreadPoolExecutor with max_workers=30
             with concurrent.futures.ThreadPoolExecutor(max_workers=self.max_upload_workers) as executor:
@@ -227,7 +230,7 @@ async def upload_rag_trace(self, ragaai_trace, additional_metadata, trace_id):
                         base_url=self.base_url
                     ).upload_traces,
                     additional_metadata_keys=additional_metadata
-                )
+                ) 
 
                 # Implement retry logic - attempt upload up to 3 times
                 max_retries = 3

ragaai_catalyst/tracers/tracer.py

@@ -427,12 +427,20 @@ def file_post_processor(original_trace_json_path: os.PathLike) -> os.PathLike:
             with open(original_path, 'r') as f:
                 data = json.load(f)
 
-            # Apply masking only to data['data']
-            data['data'] = recursive_mask_values(data['data'])
-            
-            # Create new filename with 'processed_' prefix in /var/tmp/
+            # Apply masking only to data['data'] or in case of langchain rag apply on 'traces' field of each element
+            if 'data' in data:
+                data['data'] = recursive_mask_values(data['data'])
+            elif isinstance(data,list):
+                masked_traces = []
+                for item in data:
+                    if isinstance(item, dict) and 'traces' in item:
+                        item['traces'] = recursive_mask_values(item['traces'])
+                        masked_traces.append(item)
+                data = masked_traces
+            # Create new filename with 'processed_' prefix 
             new_filename = f"processed_{original_path.name}"
-            final_trace_json_path = Path("/var/tmp") / new_filename
+            dir_name, original_filename = os.path.split(original_trace_json_path)
+            final_trace_json_path = Path(dir_name) / new_filename
 
             # Write modified data to the new file
             with open(final_trace_json_path, 'w') as f:
@@ -538,7 +546,7 @@ def set_dataset_name(self, dataset_name):
 
     def _improve_metadata(self, metadata, tracer_type):
         if metadata is None:
-            metadata = {"metadata": {}}
+            metadata = {}
         metadata.setdefault("log_source", f"{tracer_type}_tracer")
         metadata.setdefault("recorded_on", str(datetime.datetime.now()))
         return metadata
@@ -859,3 +867,30 @@ def add_context(self, context):
             self.user_context = context
         else:
             raise TypeError("context must be a string")
+    
+    def add_metadata(self, metadata):
+        """
+        Add metadata information to the trace. This method is only supported for 'langchain' and 'llamaindex' tracer types.
+
+        Args:
+            metadata: Additional metadata information to be added to the trace. Can be a dictionary.
+
+        Raises:
+            ValueError: If tracer_type is not 'langchain' or 'llamaindex'.
+        """
+        if self.tracer_type not in ["langchain", "llamaindex"]:
+            raise ValueError("add_metadata is only supported for 'langchain' and 'llamaindex' tracer types")
+        
+        # Convert string metadata to string if needed
+        user_details = self.user_details
+        user_metadata = user_details["trace_user_detail"]["metadata"]
+        if isinstance(metadata, dict):
+            for key, value in metadata.items():
+                if key in user_metadata:
+                    user_metadata[key] = value
+                else:
+                    raise ValueError(f"Key '{key}' not found in metadata")
+            self.dynamic_exporter.user_details = user_details
+            self.metadata = user_metadata
+        else:
+            raise TypeError("metadata must be a dictionary")

ragaai_catalyst/tracers/upload_traces.py

@@ -36,15 +36,23 @@ def _create_dataset_schema_with_trace(self, additional_metadata_keys=None, addit
             "model_name": {"columnType": "metadata"},
             "total_cost": {"columnType": "metadata", "dataType": "numerical"},
             "total_latency": {"columnType": "metadata", "dataType": "numerical"},
+            "error": {"columnType": "metadata"}
         }
 
         if additional_metadata_keys:
             for key in additional_metadata_keys:
                 if key == "model_name":
                     SCHEMA_MAPPING_NEW['response']["modelName"] = additional_metadata_keys[key]
+                elif key == "error":
+                    pass
                 else:
                     SCHEMA_MAPPING_NEW[key] = {"columnType": key, "parentColumn": "response"}
 
+        if self.user_detail and self.user_detail["trace_user_detail"]["metadata"]:
+            for key in self.user_detail["trace_user_detail"]["metadata"]:
+                if key not in SCHEMA_MAPPING_NEW:
+                    SCHEMA_MAPPING_NEW[key] = {"columnType": "metadata"}
+
         if additional_pipeline_keys:
             for key in additional_pipeline_keys:
                 SCHEMA_MAPPING_NEW[key] = {"columnType": "pipeline"}

ragaai_catalyst/tracers/utils/convert_langchain_callbacks_output.py

@@ -58,4 +58,5 @@ def convert_langchain_callbacks_output(result, project_name="", metadata="", pip
 
     initial_struc[0]["traces"] = traces_data
 
+    initial_struc[0]["error"] = result["error"]
     return initial_struc