ragaai-catalyst 2.1.7.5b5__py3-none-any.whl → 2.2__py3-none-any.whl

ragaai_catalyst/tracers/agentic_tracing/tracers/base.py

@@ -1269,17 +1269,7 @@ class BaseTracer:
             )
             print(f"Schema created: {response}")
             
-            # 2. Upload trace metrics
-            print("Uploading trace metrics...")
-            from ragaai_catalyst.tracers.agentic_tracing.upload.upload_trace_metric import upload_trace_metric
-            response = upload_trace_metric(
-                json_file_path=trace_file,
-                dataset_name=self.dataset_name,
-                project_name=self.project_name,
-            )
-            print(f"Metrics uploaded: {response}")
-            
-            # 3. Get code hash and zip path if available
+            # 2. Get code hash and zip path if available
             code_hash = None
             zip_path = None
             try:
@@ -1293,7 +1283,7 @@ class BaseTracer:
             except Exception as e:
                 print(f"Error getting code hash: {e}")
             
-            # 4. Upload agentic traces
+            # 3. Upload agentic traces
             print("Uploading agentic traces...")
             from ragaai_catalyst.tracers.agentic_tracing.upload.upload_agentic_traces import UploadAgenticTraces
             from ragaai_catalyst import RagaAICatalyst
@@ -1308,7 +1298,7 @@ class BaseTracer:
             upload_traces.upload_agentic_traces()
             print("Agentic traces uploaded successfully")
             
-            # 5. Upload code hash if available
+            # 4. Upload code hash if available
             if code_hash and zip_path and os.path.exists(zip_path):
                 print(f"Uploading code hash: {code_hash}")
                 from ragaai_catalyst.tracers.agentic_tracing.upload.upload_code import upload_code

ragaai_catalyst/tracers/agentic_tracing/upload/trace_uploader.py

@@ -45,7 +45,7 @@ logger = logging.getLogger("trace_uploader")
 try:
     from ragaai_catalyst.tracers.agentic_tracing.upload.upload_agentic_traces import UploadAgenticTraces
     from ragaai_catalyst.tracers.agentic_tracing.upload.upload_code import upload_code
-    from ragaai_catalyst.tracers.agentic_tracing.upload.upload_trace_metric import upload_trace_metric
+    # from ragaai_catalyst.tracers.agentic_tracing.upload.upload_trace_metric import upload_trace_metric
     from ragaai_catalyst.tracers.agentic_tracing.utils.create_dataset_schema import create_dataset_schema_with_trace
     from ragaai_catalyst import RagaAICatalyst
     IMPORTS_AVAILABLE = True
@@ -137,6 +137,7 @@ def process_upload(task_id: str, filepath: str, hash_id: str, zip_path: str,
                 dataset_name=dataset_name,
                 project_name=project_name,
                 base_url=base_url,
+                user_details=user_details,
                 timeout=timeout
             )
             logger.info(f"Dataset schema created: {response}")
@@ -145,22 +146,22 @@ def process_upload(task_id: str, filepath: str, hash_id: str, zip_path: str,
             # Continue with other steps
             
         # Step 2: Upload trace metrics
-        if filepath and os.path.exists(filepath):
-            logger.info(f"Uploading trace metrics for {filepath} with base_url: {base_url} and timeout: {timeout}")
-            try:
-                response = upload_trace_metric(
-                    json_file_path=filepath,
-                    dataset_name=dataset_name,
-                    project_name=project_name,
-                    base_url=base_url,
-                    timeout=timeout
-                )
-                logger.info(f"Trace metrics uploaded: {response}")
-            except Exception as 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")
+        # if filepath and os.path.exists(filepath):
+        #     logger.info(f"Uploading trace metrics for {filepath} with base_url: {base_url} and timeout: {timeout}")
+        #     try:
+        #         response = upload_trace_metric(
+        #             json_file_path=filepath,
+        #             dataset_name=dataset_name,
+        #             project_name=project_name,
+        #             base_url=base_url,
+        #             timeout=timeout
+        #         )
+        #         logger.info(f"Trace metrics uploaded: {response}")
+        #     except Exception as e:  
+        #         logger.error(f"Error uploading trace metrics: {e}")
+        #         # Continue with other uploads
+        # else:
+        #     logger.warning(f"Trace file {filepath} not found, skipping metrics upload")
         
         # Step 3: Upload agentic traces
         if filepath and os.path.exists(filepath):

ragaai_catalyst/tracers/agentic_tracing/upload/upload_agentic_traces.py

@@ -163,55 +163,23 @@ class UploadAgenticTraces:
             return None
         try:
             spans = data["data"][0]["spans"]
-            datasetSpans = []
+            dataset_spans = []
             for span in spans:
-                if span["type"] != "agent":
-                    existing_span = next((s for s in datasetSpans if s["spanHash"] == span["hash_id"]), None)
-                    if existing_span is None:
-                        datasetSpans.append({
-                            "spanId": span["id"],
-                            "spanName": span["name"],
-                            "spanHash": span["hash_id"],
-                            "spanType": span["type"],
-                        })
-                else:
-                    datasetSpans.extend(self._get_agent_dataset_spans(span, datasetSpans))
-            datasetSpans = [dict(t) for t in set(tuple(sorted(d.items())) for d in datasetSpans)]
-            
-            return datasetSpans
+                try:
+                    dataset_spans.append({
+                        "spanId": span.get("context", {}).get("span_id", ""),
+                        "spanName": span.get("name", ""),
+                        "spanHash": span.get("hash_id", ""),
+                        "spanType": span.get("attributes", {}).get("openinference.span.kind", ""),
+                    })
+                except Exception as e:
+                    logger.warning(f"Error processing span: {e}")
+                    continue
+            return dataset_spans
         except Exception as e:
             print(f"Error while reading dataset spans: {e}")
             return None
 
-    def _get_agent_dataset_spans(self, span, datasetSpans):
-        datasetSpans.append({
-                                "spanId": span["id"],
-                                "spanName": span["name"],
-                                "spanHash": span["hash_id"],
-                                "spanType": span["type"],
-                            })
-        children = span["data"]["children"]
-        for child in children:
-            if child["type"] != "agent":
-                existing_span = next((s for s in datasetSpans if s["spanHash"] == child["hash_id"]), None)
-                if existing_span is None:
-                    datasetSpans.append({
-                        "spanId": child["id"],
-                        "spanName": child["name"],
-                        "spanHash": child["hash_id"],
-                        "spanType": child["type"],
-                    })
-            else:
-                datasetSpans.append({
-                            "spanId": child["id"],
-                            "spanName": child["name"],
-                            "spanHash": child["hash_id"],
-                            "spanType": child["type"],
-                        })
-                self._get_agent_dataset_spans(child, datasetSpans)
-        return datasetSpans
-        
-
     def upload_agentic_traces(self):
         try:
             presignedUrl = self._get_presigned_url()

ragaai_catalyst/tracers/agentic_tracing/utils/create_dataset_schema.py

@@ -4,17 +4,32 @@ import re
 import requests
 from ragaai_catalyst.tracers.agentic_tracing.tracers.base import RagaAICatalyst
 
-def create_dataset_schema_with_trace(project_name, dataset_name, base_url=None, timeout=120):
+def create_dataset_schema_with_trace(project_name, dataset_name, base_url=None, user_details=None, timeout=120):
+    SCHEMA_MAPPING = {}
+    metadata = user_details.get("trace_user_detail").get("metadata")
+    if metadata and isinstance(metadata, dict):
+        for key, value in metadata.items():
+            if key in ["log_source", "recorded_on"]:
+                continue
+            SCHEMA_MAPPING[key] = {"columnType": "metadata"}
+
     def make_request():
         headers = {
             "Content-Type": "application/json",
             "Authorization": f"Bearer {os.getenv('RAGAAI_CATALYST_TOKEN')}",
             "X-Project-Name": project_name,
         }
-        payload = json.dumps({
-            "datasetName": dataset_name,
-            "traceFolderUrl": None,
-        })
+        if SCHEMA_MAPPING:
+            payload = json.dumps({
+                "datasetName": dataset_name,
+                "traceFolderUrl": None,
+                "schemaMapping": SCHEMA_MAPPING
+            })
+        else:
+            payload = json.dumps({
+                "datasetName": dataset_name,
+                "traceFolderUrl": None,
+            })
         # Use provided base_url or fall back to default
         url_base = base_url if base_url is not None else RagaAICatalyst.BASE_URL
         response = requests.request("POST",

ragaai_catalyst/tracers/exporters/dynamic_trace_exporter.py

@@ -14,7 +14,7 @@ class DynamicTraceExporter(SpanExporter):
     certain properties to be updated dynamically during execution.
     """
     
-    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, max_upload_workers = 30,user_context = None, external_id=None):
+    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, max_upload_workers = 30,user_context = None, user_gt = None, external_id=None):
         """
         Initialize the DynamicTraceExporter.
         
@@ -42,6 +42,7 @@ class DynamicTraceExporter(SpanExporter):
             post_processor= post_processor,
             max_upload_workers = max_upload_workers,
             user_context = user_context,
+            user_gt = user_gt,
             external_id=external_id
         )
         
@@ -56,6 +57,8 @@ class DynamicTraceExporter(SpanExporter):
         self._post_processor = post_processor
         self._max_upload_workers = max_upload_workers
         self._user_context = user_context
+        self._user_gt = user_gt
+        self._external_id = external_id
 
     
     def export(self, spans):
@@ -115,6 +118,8 @@ class DynamicTraceExporter(SpanExporter):
         self._exporter.post_processor = self._post_processor
         self._exporter.max_upload_workers = self._max_upload_workers
         self._exporter.user_context = self._user_context
+        self._exporter.user_gt = self._user_gt    
+        self._exporter.external_id = self._external_id
     
     # Getter and setter methods for dynamic properties
     
@@ -190,3 +195,19 @@ class DynamicTraceExporter(SpanExporter):
     def user_context(self, value):
         self._user_context = value
 
+    @property
+    def user_gt(self):
+        return self._user_gt
+    
+    @user_gt.setter
+    def user_gt(self, value):
+        self._user_gt = value
+
+    @property
+    def external_id(self):
+        return self._external_id
+    
+    @external_id.setter
+    def external_id(self, value):
+        self._external_id = value
+    

ragaai_catalyst/tracers/exporters/ragaai_trace_exporter.py

@@ -26,7 +26,7 @@ logging_level = (
 
 
 class RAGATraceExporter(SpanExporter):
-    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, max_upload_workers = 30,user_context = None, external_id=None):
+    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, max_upload_workers = 30,user_context = None, user_gt = None, external_id=None):
         self.trace_spans = dict()
         self.tmp_dir = tempfile.gettempdir()
         self.tracer_type = tracer_type
@@ -42,6 +42,7 @@ class RAGATraceExporter(SpanExporter):
         self.post_processor = post_processor
         self.max_upload_workers = max_upload_workers
         self.user_context = user_context
+        self.user_gt = user_gt
         self.external_id = external_id
 
     def export(self, spans):
@@ -82,10 +83,7 @@ class RAGATraceExporter(SpanExporter):
     def process_complete_trace(self, spans, trace_id):
         # Convert the trace to ragaai trace format
         try:
-            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)
+            ragaai_trace_details = self.prepare_trace(spans, trace_id)
         except Exception as e:
             print(f"Error converting trace {trace_id}: {e}")
             return  # Exit early if conversion fails
@@ -97,33 +95,16 @@ class RAGATraceExporter(SpanExporter):
             
         # Upload the trace if upload_trace function is provided
         try:
-            if self.post_processor!=None and self.tracer_type != "langchain":
+            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":
-                # Check if we're already in an event loop
-                try:
-                    loop = asyncio.get_event_loop()
-                    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, 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, self.post_processor))
-                except RuntimeError:
-                    # No event loop exists, create one
-                    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: 
+            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:
             try:
-                ragaai_trace = convert_json_format(spans, self.custom_model_cost)   
+                ragaai_trace = convert_json_format(spans, self.custom_model_cost, self.user_context, self.user_gt,self.external_id)   
             except Exception as e:
                 print(f"Error in convert_json_format function: {trace_id}: {e}")
                 return None
@@ -169,12 +150,32 @@ class RAGATraceExporter(SpanExporter):
             except Exception as e:
                 print(f"Error in adding project name: {trace_id}: {e}")
                 return None
+
+            try:
+                # Add tracer type to the trace
+                ragaai_trace["tracer_type"] = self.tracer_type
+            except Exception as e:
+                print(f"Error in adding tracer type: {trace_id}: {e}")
+                return None
+            
+            #Add user passed metadata to the trace
+            try:
+                if self.user_details.get("trace_user_detail").get("metadata") and isinstance(self.user_details.get("trace_user_detail").get("metadata"), dict):
+                    for key, value in self.user_details.get("trace_user_detail").get("metadata").items():
+                        if key in ["log_source", "recorded_on"]:
+                            continue
+                        ragaai_trace["metadata"][key] = value
+            except Exception as e:
+                print(f"Error in adding metadata: {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)
+                with open(os.path.join(os.getcwd(), 'rag_agent_traces.json'), 'w') as f:
+                    json.dump(ragaai_trace, f, cls=TracerJSONEncoder, indent=2)
             except Exception as e:
                 print(f"Error in saving trace json: {trace_id}: {e}")
                 return None
@@ -204,74 +205,4 @@ class RAGATraceExporter(SpanExporter):
                 timeout=self.timeout
             )
 
-        logger.info(f"Submitted upload task with ID: {self.upload_task_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:
-                # 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,self.user_context)
-            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
+        logger.info(f"Submitted upload task with ID: {self.upload_task_id}")