ragaai-catalyst 2.1.6.4b0__py3-none-any.whl → 2.1.7b0__py3-none-any.whl

ragaai_catalyst/tracers/exporters/ragaai_trace_exporter.py

@@ -10,7 +10,14 @@ from ragaai_catalyst.tracers.agentic_tracing.utils.system_monitor import SystemM
 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
-
+from ragaai_catalyst.tracers.utils.rag_trace_json_converter import rag_trace_json_converter
+from ragaai_catalyst.tracers.utils.convert_langchain_callbacks_output import convert_langchain_callbacks_output
+from ragaai_catalyst.tracers.upload_traces import UploadTraces
+import datetime
+import logging
+import asyncio
+import concurrent.futures
+from functools import partial
 
 logger = logging.getLogger("RagaAICatalyst")
 logging_level = (
@@ -19,9 +26,10 @@ logging_level = (
 
 
 class RAGATraceExporter(SpanExporter):
-    def __init__(self, files_to_zip, project_name, project_id, dataset_name, user_details, base_url, custom_model_cost, timeout=120):
+    def __init__(self, tracer_type, files_to_zip, project_name, project_id, dataset_name, user_details, base_url, custom_model_cost, timeout=120, post_processor = None):
         self.trace_spans = dict()
         self.tmp_dir = tempfile.gettempdir()
+        self.tracer_type = tracer_type
         self.files_to_zip = files_to_zip
         self.project_name = project_name
         self.project_id = project_id
@@ -31,29 +39,34 @@ class RAGATraceExporter(SpanExporter):
         self.custom_model_cost = custom_model_cost
         self.system_monitor = SystemMonitor(dataset_name)
         self.timeout = timeout
+        self.post_processor = post_processor
 
     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 is None:
-                raise Exception("Trace ID is None")
-
-            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]
-                try:
-                    self.process_complete_trace(trace, trace_id)
-                except Exception as e:
-                    raise Exception(f"Error processing complete trace: {e}")
-                try:
-                    del self.trace_spans[trace_id]
-                except Exception as e:
-                    raise Exception(f"Error deleting trace: {e}")
+            try:
+                span_json = json.loads(span.to_json())
+                trace_id = span_json.get("context").get("trace_id")
+                if trace_id is None:
+                    raise Exception("Trace ID is None")
+
+                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]
+                    try:
+                        self.process_complete_trace(trace, trace_id)
+                    except Exception as e:
+                        raise Exception(f"Error processing complete trace: {e}")
+                    try:
+                        del self.trace_spans[trace_id]
+                    except Exception as e:
+                        raise Exception(f"Error deleting trace: {e}")
+            except Exception as e:
+                logger.warning(f"Error processing span: {e}")
+                continue
 
         return SpanExportResult.SUCCESS
 
@@ -66,40 +79,81 @@ class RAGATraceExporter(SpanExporter):
     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)
+            if self.tracer_type == "langchain":
+                ragaai_trace_details, additional_metadata = self.prepare_rag_trace(spans, trace_id)
+            else:
+                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)
+            if self.post_processor!=None:
+                ragaai_trace_details['trace_file_path'] = self.post_processor(ragaai_trace_details['trace_file_path'])
+            if self.tracer_type == "langchain":
+                asyncio.run(self.upload_rag_trace(ragaai_trace_details, additional_metadata, trace_id))
+            else:
+                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)   
-            interactions = format_interactions(ragaai_trace)         
-            ragaai_trace["workflow"] = interactions['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
+            try:
+                ragaai_trace = convert_json_format(spans, self.custom_model_cost)   
+            except Exception as e:
+                print(f"Error in convert_json_format function: {trace_id}: {e}")
+                return None
             
-            # 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)
+            try:
+                interactions = format_interactions(ragaai_trace)         
+                ragaai_trace["workflow"] = interactions['workflow']
+            except Exception as e:
+                print(f"Error in format_interactions function: {trace_id}: {e}")
+                return None
+
+            try:
+                # Add source code hash
+                hash_id, zip_path = zip_list_of_unique_files(
+                    self.files_to_zip, output_dir=self.tmp_dir
+                )
+            except Exception as e:
+                print(f"Error in zip_list_of_unique_files function: {trace_id}: {e}")
+                return None
+
+            try:
+                ragaai_trace["metadata"]["system_info"] = asdict(self.system_monitor.get_system_info())
+                ragaai_trace["metadata"]["resources"] = asdict(self.system_monitor.get_resources())
+            except Exception as e:
+                print(f"Error in get_system_info or get_resources function: {trace_id}: {e}")
+                return None
+
+            try:
+                ragaai_trace["metadata"]["system_info"]["source_code"] = hash_id
+            except Exception as e:
+                print(f"Error in adding source code hash: {trace_id}: {e}")
+                return None
+
+            try:
+                ragaai_trace["data"][0]["start_time"] = ragaai_trace["start_time"]
+                ragaai_trace["data"][0]["end_time"] = ragaai_trace["end_time"]
+            except Exception as e:
+                print(f"Error in adding start_time or end_time: {trace_id}: {e}")
+                return None
+
+            try:
+                ragaai_trace["project_name"] = self.project_name
+            except Exception as e:
+                print(f"Error in adding project name: {trace_id}: {e}")
+                return None
+            
+            try:
+                # 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)
+            except Exception as e:
+                print(f"Error in saving trace json: {trace_id}: {e}")
+                return None
 
             return {
                 'trace_file_path': trace_file_path,
@@ -107,14 +161,13 @@ class RAGATraceExporter(SpanExporter):
                 'hash_id': hash_id
             }
         except Exception as e:
-            logger.error(f"Error converting trace {trace_id}: {str(e)}")
+            print(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']  
-
+        zip_path = ragaai_trace_details['code_zip_path']
         self.upload_task_id = submit_upload_task(
                 filepath=filepath,
                 hash_id=hash_id,
@@ -127,4 +180,69 @@ class RAGATraceExporter(SpanExporter):
                 timeout=self.timeout
             )
 
-        logger.info(f"Submitted upload task with ID: {self.upload_task_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):
+        try:
+            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)
+            
+            # Create a ThreadPoolExecutor with max_workers=30
+            with concurrent.futures.ThreadPoolExecutor(max_workers=30) as executor:
+                # Create a partial function with all the necessary arguments
+                upload_func = partial(
+                    UploadTraces(
+                        json_file_path=trace_file_path,
+                        project_name=self.project_name,
+                        project_id=self.project_id,
+                        dataset_name=self.dataset_name,
+                        user_detail=self.user_details,
+                        base_url=self.base_url
+                    ).upload_traces,
+                    additional_metadata_keys=additional_metadata
+                )
+                
+                # Implement retry logic - attempt upload up to 3 times
+                max_retries = 3
+                retry_count = 0
+                last_exception = None
+                
+                while retry_count < max_retries:
+                    try:
+                        # Submit the task to the executor and get a future
+                        loop = asyncio.get_event_loop()
+                        await loop.run_in_executor(executor, upload_func)
+                        
+                        logger.info(f"Successfully uploaded rag trace {trace_id} on attempt {retry_count + 1}")
+                        return  # Exit the method if upload is successful
+                    except Exception as e:
+                        retry_count += 1
+                        last_exception = e
+                        logger.warning(f"Attempt {retry_count} to upload rag trace {trace_id} failed: {str(e)}")
+                        
+                        if retry_count < max_retries:
+                            # Add a small delay before retrying (exponential backoff)
+                            await asyncio.sleep(2 ** retry_count)  # 2, 4, 8 seconds
+                
+                # If we've exhausted all retries, log the error
+                logger.error(f"Failed to upload rag trace {trace_id} after {max_retries} attempts. Last error: {str(last_exception)}")
+        except Exception as e:
+            logger.error(f"Error preparing rag trace {trace_id} for upload: {str(e)}")
+    
+    def prepare_rag_trace(self, spans, trace_id):
+        try:            
+            ragaai_trace, additional_metadata = rag_trace_json_converter(spans, self.custom_model_cost, trace_id, self.user_details, self.tracer_type)
+            ragaai_trace["metadata"]["recorded_on"] = datetime.datetime.now().astimezone().isoformat()
+            ragaai_trace["metadata"]["log_source"] = "langchain_tracer"
+
+            if True:
+                converted_ragaai_trace = convert_langchain_callbacks_output(ragaai_trace, self.project_name, ragaai_trace["metadata"], ragaai_trace["pipeline"])
+            else:
+                converted_ragaai_trace = ragaai_trace
+            
+            return converted_ragaai_trace, additional_metadata
+            
+        except Exception as e:
+            logger.error(f"Error converting trace {trace_id}: {str(e)}")
+            return None

ragaai_catalyst/tracers/tracer.py

@@ -6,7 +6,7 @@ import asyncio
 import aiohttp
 import requests
 from litellm import model_cost
-
+from pathlib import Path
 from contextlib import contextmanager
 from concurrent.futures import ThreadPoolExecutor
 from ragaai_catalyst.tracers.langchain_callback import LangchainTracer
@@ -71,7 +71,7 @@ class Tracer(AgenticTracing):
             pipeline (dict, optional): The pipeline configuration. Defaults to None.
             metadata (dict, optional): The metadata. Defaults to None.
             description (str, optional): The description. Defaults to None.
-            timeout (int, optional): The upload timeout in seconds. Defaults to 30.
+            timeout (int, optional): The upload timeout in seconds. Defaults to 120.
             update_llm_cost (bool, optional): Whether to update model costs from GitHub. Defaults to True.
         """
 
@@ -134,11 +134,13 @@ class Tracer(AgenticTracing):
         self.description = description
         self.timeout = timeout
         self.base_url = f"{RagaAICatalyst.BASE_URL}"
+        self.timeout = timeout
         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()
+        self.post_processor = None
         
         try:
             response = requests.get(
@@ -169,16 +171,18 @@ class Tracer(AgenticTracing):
             raise
 
         if tracer_type == "langchain":
-            # self.raga_client = RagaExporter(project_name=self.project_name, dataset_name=self.dataset_name)
-
-            # self._tracer_provider = self._setup_provider()
-            # self._instrumentor = self._setup_instrumentor(tracer_type)
-            # self.is_instrumented = False
-            # self._upload_task = None
-            self._upload_task = None
+            instrumentors = []
+            from openinference.instrumentation.langchain import LangChainInstrumentor
+            instrumentors += [(LangChainInstrumentor, [])]
+            self._setup_agentic_tracer(instrumentors)
         elif tracer_type == "llamaindex":
             self._upload_task = None
             self.llamaindex_tracer = None
+        elif tracer_type == "rag/langchain":
+            instrumentors = []
+            from openinference.instrumentation.langchain import LangChainInstrumentor
+            instrumentors += [(LangChainInstrumentor, [])]
+            self._setup_agentic_tracer(instrumentors)
         # Handle agentic tracers
         elif tracer_type == "agentic" or tracer_type.startswith("agentic/"):
             
@@ -367,6 +371,95 @@ class Tracer(AgenticTracing):
             "output_cost_per_token": float(cost_config["output_cost_per_million_token"]) /1000000
         }
 
+    def register_masking_function(self, masking_func):
+        """
+        Register a masking function that will be used to transform values in the trace data.
+        This method handles all file operations internally and creates a post-processor
+        using the provided masking function.
+        
+        Args:
+            masking_func (callable): A function that takes a value and returns the masked value.
+                The function should handle string transformations for masking sensitive data.
+                
+                Example:
+                def masking_function(value):
+                    if isinstance(value, str):
+                        value = re.sub(r'\b\d+\.\d+\b', 'x.x', value)
+                        value = re.sub(r'\b\d+\b', 'xxxx', value)
+                    return value
+        """
+        if not callable(masking_func):
+            raise TypeError("masking_func must be a callable")
+
+        def recursive_mask_values(obj, parent_key=None):
+            """Apply masking to all values in nested structure."""
+            if isinstance(obj, dict):
+                return {k: recursive_mask_values(v, k) for k, v in obj.items()}
+            elif isinstance(obj, list):
+                return [recursive_mask_values(item, parent_key) for item in obj]
+            elif isinstance(obj, str):
+                # List of keys that should NOT be masked
+                excluded_keys = {
+                    'start_time', 'end_time', 'name', 'id', 
+                    'hash_id', 'parent_id', 'source_hash_id',
+                    'cost', 'type', 'feedback', 'error', 'ctx','telemetry.sdk.version',
+                    'telemetry.sdk.language','service.name'
+                }
+                # Apply masking only if the key is NOT in the excluded list
+                if parent_key and parent_key.lower() not in excluded_keys:
+                    return masking_func(obj)
+                return obj
+            else:
+                return obj
+
+        def file_post_processor(original_trace_json_path: os.PathLike) -> os.PathLike:
+            original_path = Path(original_trace_json_path)
+            
+            # Read original JSON data
+            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/
+            new_filename = f"processed_{original_path.name}"
+            final_trace_json_path = Path("/var/tmp") / new_filename
+            
+            # Write modified data to the new file
+            with open(final_trace_json_path, 'w') as f:
+                json.dump(data, f, indent=4)
+            
+            logger.debug(f"Created masked trace file: {final_trace_json_path}")
+            return final_trace_json_path
+
+        # Register the created post-processor
+        self.register_post_processor(file_post_processor)
+        logger.debug("Masking function registered successfully as post-processor")
+
+    
+    def register_post_processor(self, post_processor_func):
+        """
+        Register a post-processing function that will be called after trace generation.
+        
+        Args:
+            post_processor_func (callable): A function that takes a trace JSON file path as input
+                and returns a processed trace JSON file path.
+                The function signature should be:
+                def post_processor_func(original_trace_json_path: os.PathLike) -> os.PathLike
+        """
+        if not callable(post_processor_func):
+            raise TypeError("post_processor_func must be a callable")
+        self.post_processor = post_processor_func
+        # Register in parent AgenticTracing class
+        super().register_post_processor(post_processor_func)
+        # Update DynamicTraceExporter's post-processor if it exists
+        if hasattr(self, 'dynamic_exporter'):
+            self.dynamic_exporter._exporter.post_processor = post_processor_func
+            self.dynamic_exporter._post_processor = post_processor_func
+        logger.info("Registered post process as: "+str(post_processor_func))
+    
+
     def set_dataset_name(self, dataset_name):
         """
         Reinitialize the Tracer with a new dataset name while keeping all other parameters the same.
@@ -455,15 +548,14 @@ class Tracer(AgenticTracing):
     def start(self):
         """Start the tracer."""
         if self.tracer_type == "langchain":
-            # if not self.is_instrumented:
-            #     self._instrumentor().instrument(tracer_provider=self._tracer_provider)
-            #     self.is_instrumented = True
-            # print(f"Tracer started for project: {self.project_name}")
-            self.langchain_tracer = LangchainTracer()
-            return self.langchain_tracer.start()
+            super().start()
+            return self
         elif self.tracer_type == "llamaindex":
             self.llamaindex_tracer = LlamaIndexInstrumentationTracer(self._pass_user_data())
             return self.llamaindex_tracer.start()
+        elif self.tracer_type == "rag/langchain":
+            super().start()
+            return self
         else:
             super().start()
             return self
@@ -471,104 +563,8 @@ class Tracer(AgenticTracing):
     def stop(self):
         """Stop the tracer and initiate trace upload."""
         if self.tracer_type == "langchain":
-            # if not self.is_instrumented:
-            #     logger.warning("Tracer was not started. No traces to upload.")
-            #     return "No traces to upload"
-
-            # print("Stopping tracer and initiating trace upload...")
-            # self._cleanup()
-            # self._upload_task = self._run_async(self._upload_traces())
-            # self.is_active = False
-            # self.dataset_name = None
-            
-            user_detail = self._pass_user_data()
-            data, additional_metadata = self.langchain_tracer.stop()
-
-            # Add cost if possible
-            if additional_metadata.get('model_name'):
-                try:
-                    if self.model_custom_cost.get(additional_metadata['model_name']):
-                        model_cost_data = self.model_custom_cost[additional_metadata['model_name']]
-                    else:
-                        model_cost_data = self.model_cost_dict[additional_metadata['model_name']]
-                    if 'tokens' in additional_metadata and all(k in additional_metadata['tokens'] for k in ['prompt', 'completion']):
-                        prompt_cost = additional_metadata["tokens"]["prompt"]*model_cost_data["input_cost_per_token"]
-                        completion_cost = additional_metadata["tokens"]["completion"]*model_cost_data["output_cost_per_token"]
-                        additional_metadata["cost"] = prompt_cost + completion_cost 
-
-                        additional_metadata["prompt_tokens"] = float(additional_metadata["tokens"].get("prompt", 0.0))
-                        additional_metadata["completion_tokens"] = float(additional_metadata["tokens"].get("completion", 0.0))
-
-                        logger.debug("Metadata added successfully")
-                    else:
-                        logger.warning("Token information missing in additional_metadata")
-
-                    if 'cost' in additional_metadata:
-                        additional_metadata["cost"] = float(additional_metadata["cost"])
-                    else:
-                        additional_metadata["cost"] = 0.0
-                        logger.warning("Total cost information not available")
-
-
-                except Exception as e:
-                    logger.warning(f"Error adding cost: {e}")
-            else:
-                logger.debug("Model name not available in additional_metadata, skipping cost calculation")
-            
-
-            # Safely remove tokens and cost dictionaries if they exist
-            additional_metadata.pop("tokens", None)
-            # additional_metadata.pop("cost", None)
-
-            additional_metadata["model"] = additional_metadata.get("model_name", "")
-            
-            # Safely merge metadata
-            combined_metadata = {}
-            if user_detail.get('trace_user_detail', {}).get('metadata'):
-                combined_metadata.update(user_detail['trace_user_detail']['metadata'])
-            if additional_metadata:
-                combined_metadata.update(additional_metadata)
-                
-            model_cost_latency_metadata = {}
-            if additional_metadata:
-                model_cost_latency_metadata["model_name"] = additional_metadata["model_name"]
-                model_cost_latency_metadata["total_cost"] = additional_metadata["cost"]
-                model_cost_latency_metadata["total_latency"] = additional_metadata["latency"]
-                model_cost_latency_metadata["recorded_on"] = datetime.datetime.now().astimezone().isoformat()
-                combined_metadata.update(model_cost_latency_metadata)
-
-            langchain_traces = langchain_tracer_extraction(data, self.user_context)
-            final_result = convert_langchain_callbacks_output(langchain_traces)
-            
-            # Safely set required fields in final_result
-            if final_result and isinstance(final_result, list) and len(final_result) > 0:
-                final_result[0]['project_name'] = user_detail.get('project_name', '')
-                final_result[0]['trace_id'] = str(uuid.uuid4())
-                final_result[0]['session_id'] = None
-                final_result[0]['metadata'] = combined_metadata
-                final_result[0]['pipeline'] = user_detail.get('trace_user_detail', {}).get('pipeline')
-
-                filepath_3 = os.path.join(os.getcwd(), "final_result.json")
-                with open(filepath_3, 'w') as f:
-                    json.dump(final_result, f, indent=2)
-                
-                # print(filepath_3)
-            else:
-                logger.warning("No valid langchain traces found in final_result")
-
-            # additional_metadata_keys = list(additional_metadata.keys()) if additional_metadata else None
-            additional_metadata_dict = additional_metadata if additional_metadata else {}
-
-            UploadTraces(json_file_path=filepath_3,
-                         project_name=self.project_name,
-                         project_id=self.project_id,
-                         dataset_name=self.dataset_name,
-                         user_detail=self._pass_user_data(),
-                         base_url=self.base_url
-                         ).upload_traces(additional_metadata_keys=additional_metadata_dict)
-            
-            return 
-
+            super().stop()
+            return self
         elif self.tracer_type == "llamaindex":
             if self.llamaindex_tracer is None:
                 raise ValueError("LlamaIndex tracer was not started")
@@ -580,8 +576,18 @@ class Tracer(AgenticTracing):
             with open(filepath_3, 'w') as f:
                 json.dump(converted_back_to_callback, f, default=str, indent=2)
 
+            # Apply post-processor if registered
+            if self.post_processor is not None:
+                try:
+                    final_trace_filepath = self.post_processor(filepath_3)
+                    logger.debug(f"Post-processor applied successfully, new path: {filepath_3}")
+                except Exception as e:
+                    logger.error(f"Error in post-processing: {e}")
+            else:
+                final_trace_filepath = filepath_3
+
             if converted_back_to_callback:
-                UploadTraces(json_file_path=filepath_3,
+                UploadTraces(json_file_path=final_trace_filepath,
                              project_name=self.project_name,
                              project_id=self.project_id,
                              dataset_name=self.dataset_name,
@@ -589,6 +595,8 @@ class Tracer(AgenticTracing):
                              base_url=self.base_url
                              ).upload_traces()
             return 
+        elif self.tracer_type == "rag/langchain":
+            super().stop()
         else:
             super().stop()
 
@@ -746,6 +754,7 @@ class Tracer(AgenticTracing):
 
         # Create a dynamic exporter that allows property updates
         self.dynamic_exporter = DynamicTraceExporter(
+            tracer_type=self.tracer_type,
             files_to_zip=list_of_unique_files,
             project_name=self.project_name,
             project_id=self.project_id,
@@ -753,7 +762,8 @@ class Tracer(AgenticTracing):
             user_details=self.user_details,
             base_url=self.base_url,
             custom_model_cost=self.model_custom_cost,
-            timeout=self.timeout
+            timeout = self.timeout,
+            post_processor= self.post_processor
         )
         
         # Set up tracer provider

ragaai_catalyst/tracers/upload_traces.py

@@ -105,7 +105,7 @@ class UploadTraces:
 
         if "blob.core.windows.net" in presignedUrl:  # Azure
             headers["x-ms-blob-type"] = "BlockBlob"
-        print(f"Uploading traces...")
+        # print(f"Uploading traces...")
         with open(filename) as f:
             payload = f.read().replace("\n", "").replace("\r", "").encode()
             
@@ -142,6 +142,6 @@ class UploadTraces:
                 return
             self._put_presigned_url(presignedUrl, self.json_file_path)
             self._insert_traces(presignedUrl)
-            print("Traces uploaded")
+            # print("Traces uploaded")
         except Exception as e:
-            print(f"Error while uploading agentic traces: {e}")
+            print(f"Error while uploading rag traces: {e}")

ragaai_catalyst/tracers/utils/convert_langchain_callbacks_output.py

@@ -3,7 +3,7 @@ import json
 def convert_langchain_callbacks_output(result, project_name="", metadata="", pipeline=""):
     initial_struc = [{
         "project_name": project_name,
-        "trace_id": "NA",
+        "trace_id": result["trace_id"],
         "session_id": "NA",
         "metadata" : metadata,
         "pipeline" : pipeline,