ragaai-catalyst 2.2.2__py3-none-any.whl → 2.2.3b0__py3-none-any.whl

ragaai_catalyst/tracers/tracer.py

@@ -1,26 +1,35 @@
-import asyncio
+import os
+import uuid
 import datetime
-import json
 import logging
-import os
-from concurrent.futures import ThreadPoolExecutor
-from contextlib import contextmanager
-from pathlib import Path
-
+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
+from ragaai_catalyst.tracers.utils.convert_langchain_callbacks_output import convert_langchain_callbacks_output
 
-# from ragaai_catalyst.tracers.llamaindex_callback import LlamaIndexTracer
-from openinference.instrumentation.langchain import LangChainInstrumentor
+from ragaai_catalyst.tracers.utils.langchain_tracer_extraction_logic import langchain_tracer_extraction
+from ragaai_catalyst.tracers.upload_traces import UploadTraces
+import tempfile
+import json
+import numpy as np
 from opentelemetry.sdk import trace as trace_sdk
 from opentelemetry.sdk.trace.export import SimpleSpanProcessor
-
+from ragaai_catalyst.tracers.exporters.file_span_exporter import FileSpanExporter
+from ragaai_catalyst.tracers.exporters.raga_exporter import RagaExporter
+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 openinference.instrumentation.langchain import LangChainInstrumentor
 from ragaai_catalyst import RagaAICatalyst
 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
-from ragaai_catalyst.tracers.exporters.file_span_exporter import FileSpanExporter
-from ragaai_catalyst.tracers.utils import get_unique_key
 
 logger = logging.getLogger(__name__)
 logging_level = (
@@ -191,16 +200,12 @@ class Tracer(AgenticTracing):
             # Add LLM Instrumentors
             if tracer_type in ['agentic/crewai']:
                 try:
-                    from openinference.instrumentation.vertexai import (
-                        VertexAIInstrumentor,
-                    )
+                    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,
-                    )
+                    from openinference.instrumentation.anthropic import AnthropicInstrumentor
                     instrumentors.append((AnthropicInstrumentor, []))
                 except (ImportError, ModuleNotFoundError):
                     logger.debug("Anthropic not available in environment")
@@ -210,16 +215,12 @@ class Tracer(AgenticTracing):
                 except (ImportError, ModuleNotFoundError):
                     logger.debug("Groq not available in environment")
                 try:
-                    from openinference.instrumentation.litellm import (
-                        LiteLLMInstrumentor,
-                    )
+                    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,
-                    )
+                    from openinference.instrumentation.mistralai import MistralAIInstrumentor
                     instrumentors.append((MistralAIInstrumentor, []))
                 except (ImportError, ModuleNotFoundError):
                     logger.debug("MistralAI not available in environment")
@@ -229,9 +230,7 @@ class Tracer(AgenticTracing):
                 except (ImportError, ModuleNotFoundError):
                     logger.debug("OpenAI not available in environment")
                 try:
-                    from openinference.instrumentation.bedrock import (
-                        BedrockInstrumentor,
-                    )
+                    from openinference.instrumentation.bedrock import BedrockInstrumentor
                     instrumentors.append((BedrockInstrumentor, []))
                 except (ImportError, ModuleNotFoundError):
                     logger.debug("Bedrock not available in environment")
@@ -244,9 +243,7 @@ class Tracer(AgenticTracing):
                 try:
                     # LlamaIndex
                     try:
-                        from openinference.instrumentation.llama_index import (
-                            LlamaIndexInstrumentor,
-                        )
+                        from openinference.instrumentation.llama_index import LlamaIndexInstrumentor
                         instrumentors.append((LlamaIndexInstrumentor, []))
                         logger.info("Instrumenting LlamaIndex...")
                     except (ImportError, ModuleNotFoundError):
@@ -254,9 +251,7 @@ class Tracer(AgenticTracing):
                     
                     # LangChain
                     try:
-                        from openinference.instrumentation.langchain import (
-                            LangChainInstrumentor,
-                        )
+                        from openinference.instrumentation.langchain import LangChainInstrumentor
                         instrumentors.append((LangChainInstrumentor, []))
                         logger.info("Instrumenting LangChain...")
                     except (ImportError, ModuleNotFoundError):
@@ -264,9 +259,7 @@ class Tracer(AgenticTracing):
                     
                     # CrewAI
                     try:
-                        from openinference.instrumentation.crewai import (
-                            CrewAIInstrumentor,
-                        )
+                        from openinference.instrumentation.crewai import CrewAIInstrumentor
                         instrumentors.append((CrewAIInstrumentor, []))
                         logger.info("Instrumenting CrewAI...")
                     except (ImportError, ModuleNotFoundError):
@@ -274,9 +267,7 @@ class Tracer(AgenticTracing):
                     
                     # Haystack
                     try:
-                        from openinference.instrumentation.haystack import (
-                            HaystackInstrumentor,
-                        )
+                        from openinference.instrumentation.haystack import HaystackInstrumentor
                         instrumentors.append((HaystackInstrumentor, []))
                         logger.info("Instrumenting Haystack...")
                     except (ImportError, ModuleNotFoundError):
@@ -284,9 +275,7 @@ class Tracer(AgenticTracing):
                     
                     # AutoGen
                     try:
-                        from openinference.instrumentation.autogen import (
-                            AutogenInstrumentor,
-                        )
+                        from openinference.instrumentation.autogen import AutogenInstrumentor
                         instrumentors.append((AutogenInstrumentor, []))
                         logger.info("Instrumenting AutoGen...")
                     except (ImportError, ModuleNotFoundError):
@@ -294,9 +283,7 @@ class Tracer(AgenticTracing):
                     
                     # Smolagents
                     try:
-                        from openinference.instrumentation.smolagents import (
-                            SmolagentsInstrumentor,
-                        )
+                        from openinference.instrumentation.smolagents import SmolagentsInstrumentor
                         instrumentors.append((SmolagentsInstrumentor, []))
                         logger.info("Instrumenting Smolagents...")
                     except (ImportError, ModuleNotFoundError):
@@ -304,9 +291,7 @@ class Tracer(AgenticTracing):
 
                     # OpenAI Agents
                     try:
-                        from openinference.instrumentation.openai_agents import (
-                            OpenAIAgentsInstrumentor,
-                        )
+                        from openinference.instrumentation.openai_agents import OpenAIAgentsInstrumentor
                         instrumentors.append((OpenAIAgentsInstrumentor, []))
                         logger.info("Instrumenting OpenAI Agents...")
                     except (ImportError, ModuleNotFoundError):
@@ -324,22 +309,16 @@ class Tracer(AgenticTracing):
             
             # Handle specific framework instrumentation
             elif tracer_type == "agentic/llamaindex" or tracer_type == "llamaindex":
-                from openinference.instrumentation.llama_index import (
-                    LlamaIndexInstrumentor,
-                )
+                from openinference.instrumentation.llama_index import LlamaIndexInstrumentor
                 instrumentors += [(LlamaIndexInstrumentor, [])] 
 
             elif tracer_type == "agentic/langchain" or tracer_type == "agentic/langgraph" or tracer_type == "langchain":
-                from openinference.instrumentation.langchain import (
-                    LangChainInstrumentor,
-                )
+                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,
-                )
+                from openinference.instrumentation.langchain import LangChainInstrumentor
                 instrumentors += [(CrewAIInstrumentor, []), (LangChainInstrumentor, [])]
             
             elif tracer_type == "agentic/haystack":
@@ -351,15 +330,11 @@ class Tracer(AgenticTracing):
                 instrumentors += [(AutogenInstrumentor, [])]
             
             elif tracer_type == "agentic/smolagents":
-                from openinference.instrumentation.smolagents import (
-                    SmolagentsInstrumentor,
-                )
+                from openinference.instrumentation.smolagents import SmolagentsInstrumentor
                 instrumentors += [(SmolagentsInstrumentor, [])]
 
             elif tracer_type == "agentic/openai_agents":
-                from openinference.instrumentation.openai_agents import (
-                    OpenAIAgentsInstrumentor,
-                )
+                from openinference.instrumentation.openai_agents import OpenAIAgentsInstrumentor
                 instrumentors += [(OpenAIAgentsInstrumentor, [])] 
             
             else:
@@ -440,7 +415,10 @@ class Tracer(AgenticTracing):
                         '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'
+                        'telemetry.sdk.language','service.name', 'llm.model_name',
+                        'llm.invocation_parameters', 'metadata', 'openinference.span.kind',
+                        'llm.token_count.prompt', 'llm.token_count.completion', 'llm.token_count.total',
+                        "input_cost", "output_cost", "total_cost", "status_code"
                     }
                     # Apply masking only if the key is NOT in the excluded list
                     if parent_key and parent_key.lower() not in excluded_keys:
@@ -825,10 +803,7 @@ class Tracer(AgenticTracing):
         """
         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,
-        )
+        from ragaai_catalyst.tracers.exporters.dynamic_trace_exporter import DynamicTraceExporter
         
         # Get the code_files
         self.file_tracker.trace_main_file()

ragaai_catalyst/tracers/utils/trace_json_converter.py

@@ -15,6 +15,7 @@ from ragaai_catalyst.tracers.agentic_tracing.utils.llm_utils import (
 
 logger = logging.getLogger(__name__)
 
+
 def convert_time_format(original_time_str, target_timezone_str="Asia/Kolkata"):
     """
     Converts a UTC time string to a specified timezone format.
@@ -36,7 +37,7 @@ def convert_time_format(original_time_str, target_timezone_str="Asia/Kolkata"):
     # Format the datetime object to the desired string format
     formatted_time = target_time.strftime("%Y-%m-%dT%H:%M:%S.%f%z")
     # Add a colon in the timezone offset for better readability
-    formatted_time = formatted_time[:-2] + ':' + formatted_time[-2:]
+    formatted_time = formatted_time[:-2] + ":" + formatted_time[-2:]
     return formatted_time
 
 
@@ -44,35 +45,43 @@ 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]
+        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):
     data = input_trace.copy()
     from collections import defaultdict
-        
+
     name_counts = defaultdict(int)
 
     for span in data:
         # 1. For each span add '.{occurence_no}' to the span name, where occurence_no is the number of times the span name has occurred
         span["name_occurrences"] = name_counts[span["name"]]
         name_counts[span["name"]] += 1
-        span['name'] = f"{span['name']}.{span['name_occurrences']}"
+        span["name"] = f"{span['name']}.{span['name_occurrences']}"
 
         # 2. For each span add hash_id, which is uuid4 based on the span name
-        span['hash_id'] = get_uuid(span['name'])
+        span["hash_id"] = get_uuid(span["name"])
     return data
 
-def convert_json_format(input_trace, custom_model_cost, user_context, user_gt,external_id):
+
+def convert_json_format(
+    input_trace, custom_model_cost, user_context, user_gt, external_id
+):
     """
     Converts a JSON from one format to UI format, handling nested spans.
 
@@ -82,25 +91,20 @@ def convert_json_format(input_trace, custom_model_cost, user_context, user_gt,ex
     Returns:
         final_trace: The converted JSON, or None if an error occurs.
     """
+
     final_trace = {
         "id": input_trace[0]["context"]["trace_id"],
-        "trace_name": "",  
-        "project_name": "",  
-        "start_time": convert_time_format(min(item["start_time"] for item in input_trace)),
+        "trace_name": "",
+        "project_name": "",
+        "start_time": convert_time_format(
+            min(item["start_time"] for item in input_trace)
+        ),
         "end_time": convert_time_format(max(item["end_time"] for item in input_trace)),
-        "external_id": external_id
+        "external_id": external_id,
     }
     final_trace["metadata"] = {
-        "tokens": {
-            "prompt_tokens": 0.0,
-            "completion_tokens": 0.0,
-            "total_tokens": 0.0
-        },
-        "cost": {
-            "input_cost": 0.0,
-            "output_cost": 0.0,
-            "total_cost": 0.0
-        }    
+        "tokens": {"prompt_tokens": 0.0, "completion_tokens": 0.0, "total_tokens": 0.0},
+        "cost": {"input_cost": 0.0, "output_cost": 0.0, "total_cost": 0.0},
     }
     final_trace["replays"] = {"source": None}
     final_trace["data"] = [{}]
@@ -113,27 +117,42 @@ def convert_json_format(input_trace, custom_model_cost, user_context, user_gt,ex
         # Add user passed context to the trace
         try:
             if user_context:
-                spans.append(custom_spans(user_context, "Context", input_trace[0]["context"]["trace_id"], spans[0].get("parent_id")))
+                spans.append(
+                    custom_spans(
+                        user_context,
+                        "Context",
+                        input_trace[0]["context"]["trace_id"],
+                        spans[0].get("parent_id"),
+                    )
+                )
         except Exception as e:
             print(f"Error in adding context: {e}")
             return None
-        
+
         try:
             if user_gt:
-                spans.append(custom_spans(user_gt, "GroundTruth", input_trace[0]["context"]["trace_id"], spans[0].get("parent_id")))
+                spans.append(
+                    custom_spans(
+                        user_gt,
+                        "GroundTruth",
+                        input_trace[0]["context"]["trace_id"],
+                        spans[0].get("parent_id"),
+                    )
+                )
         except Exception as e:
             print(f"Error in adding ground truth: {e}")
             return None
 
-
         final_trace["data"][0]["spans"] = spans
-        
+
         # Calculate token counts and costs from spans
         for span in spans:
             if "attributes" in span:
                 # Extract token counts
                 prompt_tokens = span["attributes"].get("llm.token_count.prompt", 0)
-                completion_tokens = span["attributes"].get("llm.token_count.completion", 0)
+                completion_tokens = span["attributes"].get(
+                    "llm.token_count.completion", 0
+                )
 
                 # If prompt tokens or/and completion tokens are not present, will calculate it using tiktoken
                 try:
@@ -141,35 +160,56 @@ def convert_json_format(input_trace, custom_model_cost, user_context, user_gt,ex
                         prompt_value = span["attributes"].get("input.value")
                         if prompt_value:
                             prompt_tokens = count_tokens(prompt_value)
-                            logger.debug(f"Prompt tokens not present, calculated it: {prompt_tokens}")
+                            logger.debug(
+                                f"Prompt tokens not present, calculated it: {prompt_tokens}"
+                            )
                     if completion_tokens == 0:
                         completion_value = span["attributes"].get("output.value")
                         if completion_value:
                             completion_tokens = count_tokens(completion_value)
-                            logger.debug(f"Completion tokens not present, calculated it: {completion_tokens}")
+                            logger.debug(
+                                f"Completion tokens not present, calculated it: {completion_tokens}"
+                            )
                 except Exception as e:
                     logger.warning(f"Failed to calculate token counts: {e}")
 
                 # Update token counts
                 final_trace["metadata"]["tokens"]["prompt_tokens"] += prompt_tokens
-                final_trace["metadata"]["tokens"]["completion_tokens"] += completion_tokens
-                final_trace["metadata"]["tokens"]["total_tokens"] += prompt_tokens + completion_tokens
+                final_trace["metadata"]["tokens"]["completion_tokens"] += (
+                    completion_tokens
+                )
+                final_trace["metadata"]["tokens"]["total_tokens"] += (
+                    prompt_tokens + completion_tokens
+                )
 
                 # Get model name from the last span
-                model_name = span["attributes"].get("llm.model_name", "")
+                model_names = [
+                    span["attributes"].get("llm.model_name", "") for span in spans
+                ]
+                model_name = next((name for name in reversed(model_names) if name), "")
                 if model_name:
                     try:
                         model_costs = get_model_cost()
                         span_cost = calculate_llm_cost(
-                            {"prompt_tokens": prompt_tokens, "completion_tokens": completion_tokens, "total_tokens": prompt_tokens + completion_tokens},
+                            {
+                                "prompt_tokens": prompt_tokens,
+                                "completion_tokens": completion_tokens,
+                                "total_tokens": prompt_tokens + completion_tokens,
+                            },
                             model_name,
                             model_costs,
-                            custom_model_cost
+                            custom_model_cost,
                         )
-                        final_trace["metadata"]["cost"]["input_cost"] += span_cost["input_cost"]
-                        final_trace["metadata"]["cost"]["output_cost"] += span_cost["output_cost"]
-                        final_trace["metadata"]["cost"]["total_cost"] += span_cost["total_cost"]
-                        
+                        final_trace["metadata"]["cost"]["input_cost"] += span_cost[
+                            "input_cost"
+                        ]
+                        final_trace["metadata"]["cost"]["output_cost"] += span_cost[
+                            "output_cost"
+                        ]
+                        final_trace["metadata"]["cost"]["total_cost"] += span_cost[
+                            "total_cost"
+                        ]
+
                         # Add cost to span attributes for debugging
                         span["attributes"]["llm.cost"] = span_cost
                     except Exception as e:
@@ -179,75 +219,82 @@ def convert_json_format(input_trace, custom_model_cost, user_context, user_gt,ex
         raise Exception(f"Error in get_spans function: {e}")
 
     # Total metadata summary
-    final_trace["metadata"]["total_cost"] = final_trace["metadata"]["cost"]["total_cost"]
-    final_trace["metadata"]["total_tokens"] = final_trace["metadata"]["tokens"]["total_tokens"]
+    final_trace["metadata"]["total_cost"] = final_trace["metadata"]["cost"][
+        "total_cost"
+    ]
+    final_trace["metadata"]["total_tokens"] = final_trace["metadata"]["tokens"][
+        "total_tokens"
+    ]
 
     return final_trace
 
+
 def custom_spans(text, span_type, trace_id, parent_id):
-    try: 
+    try:
         return {
-        "name": f"Custom{span_type}Span",
-        "context": {
-            "trace_id": trace_id,
-            "span_id": f"0x{uuid.uuid4().hex[:16]}",
-            "trace_state": "[]"
-          },
-        "kind": "SpanKind.INTERNAL",
-        "parent_id": parent_id,
-        "start_time": convert_time_format(datetime.now().strftime("%Y-%m-%dT%H:%M:%S.%fZ")),
-        "end_time": convert_time_format(datetime.now().strftime("%Y-%m-%dT%H:%M:%S.%fZ")),
-        "status": {
-            "status_code": "OK"
-          },
-        "attributes": {
-            "input.value": text,
-            "openinference.span.kind": "UNKNOWN"
-        },
-        "events": [],
-        "name_occurrences": 0,
-        "hash_id": get_uuid(f"Custom{span_type}Span")
-    }
+            "name": f"Custom{span_type}Span",
+            "context": {
+                "trace_id": trace_id,
+                "span_id": f"0x{uuid.uuid4().hex[:16]}",
+                "trace_state": "[]",
+            },
+            "kind": "SpanKind.INTERNAL",
+            "parent_id": parent_id,
+            "start_time": convert_time_format(
+                datetime.now().strftime("%Y-%m-%dT%H:%M:%S.%fZ")
+            ),
+            "end_time": convert_time_format(
+                datetime.now().strftime("%Y-%m-%dT%H:%M:%S.%fZ")
+            ),
+            "status": {"status_code": "OK"},
+            "attributes": {"input.value": text, "openinference.span.kind": "UNKNOWN"},
+            "events": [],
+            "name_occurrences": 0,
+            "hash_id": get_uuid(f"Custom{span_type}Span"),
+        }
     except Exception as e:
         logger.warning(f"Error in custom_spans function: {e}")
         return {
-        "name": f"Custom{span_type}Span",
-        "context": {
-            "trace_id": trace_id,
-            "span_id": f"0x{uuid.uuid4().hex[:16]}",
-            "trace_state": "[]"
-          },
-        "kind": "SpanKind.INTERNAL",
-        "parent_id": parent_id,
-        "start_time": convert_time_format(datetime.now().strftime("%Y-%m-%dT%H:%M:%S.%fZ")),
-        "end_time": convert_time_format(datetime.now().strftime("%Y-%m-%dT%H:%M:%S.%fZ")),
-        "status": {
-            "status_code": "ERROR",
-            "description": str(e)
-          },
-        "attributes": {
-            "input.value": text,
-            "openinference.span.kind": "UNKNOWN"
-        },
-        "events": [],
-        "name_occurrences": 0,
-        "hash_id": get_uuid(f"Custom{span_type}Span")
-    }
+            "name": f"Custom{span_type}Span",
+            "context": {
+                "trace_id": trace_id,
+                "span_id": f"0x{uuid.uuid4().hex[:16]}",
+                "trace_state": "[]",
+            },
+            "kind": "SpanKind.INTERNAL",
+            "parent_id": parent_id,
+            "start_time": convert_time_format(
+                datetime.now().strftime("%Y-%m-%dT%H:%M:%S.%fZ")
+            ),
+            "end_time": convert_time_format(
+                datetime.now().strftime("%Y-%m-%dT%H:%M:%S.%fZ")
+            ),
+            "status": {"status_code": "ERROR", "description": str(e)},
+            "attributes": {"input.value": text, "openinference.span.kind": "UNKNOWN"},
+            "events": [],
+            "name_occurrences": 0,
+            "hash_id": get_uuid(f"Custom{span_type}Span"),
+        }
+
 
 if __name__ == "__main__":
     if len(sys.argv) != 3:
-        print("Usage: python convert.py <input_openinference_trace_path> <output_trace_path>")
-        print("Example: python convert.py sample_openinference_trace/test.json output.json")
+        print(
+            "Usage: python convert.py <input_openinference_trace_path> <output_trace_path>"
+        )
+        print(
+            "Example: python convert.py sample_openinference_trace/test.json output.json"
+        )
         sys.exit(1)
     input_file_path = sys.argv[1]
     output_file_path = sys.argv[2]
-    with open(input_file_path,'r') as fin:
-        input_trace=[]
+    with open(input_file_path, "r") as fin:
+        input_trace = []
         for line in fin:
-            data=json.loads(line)
+            data = json.loads(line)
             input_trace.append(data)
         payload = convert_json_format(input_trace)
         print(payload)
-        with open(output_file_path,"w") as fout:
-            json.dump(payload,fout)
+        with open(output_file_path, "w") as fout:
+            json.dump(payload, fout)
             fout.write("\n")

{ragaai_catalyst-2.2.2.dist-info → ragaai_catalyst-2.2.3b0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ragaai_catalyst
-Version: 2.2.2
+Version: 2.2.3b0
 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>, Rishabh Pandey <rishabh.pandey@raga.ai>, Jyotsana C G <jyotsana@raga.ai>
 Requires-Python: <=3.13.2,>=3.10

{ragaai_catalyst-2.2.2.dist-info → ragaai_catalyst-2.2.3b0.dist-info}/RECORD

@@ -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=ngHe17GDSjHThrZO9uPr8yH-qYvnysPQrS7B0Aq_hJU,42071
+ragaai_catalyst/tracers/tracer.py,sha256=YphQkHARFV0qKQUSa1ip7j41rMg7S6_F4Z1rGBxJdSg,42228
 ragaai_catalyst/tracers/upload_traces.py,sha256=w1clGGfdOMpStUJX40NAlxe6dcFdN4pwcezyII0bGYA,6994
 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=yA2_4fO0rWP0O4mrqcPGt_aZiB4gluVS5nCk6Q6k1y8,12946
+ragaai_catalyst/tracers/agentic_tracing/upload/trace_uploader.py,sha256=FqHjvFdq5Pqp8iZcLTwXaxnMmm8ATec3fLdDuzLITFs,13019
 ragaai_catalyst/tracers/agentic_tracing/upload/upload_agentic_traces.py,sha256=qcii8NMZGJvmv19AokjCH2egGIsALLWK9JqHtgkFB_0,10447
 ragaai_catalyst/tracers/agentic_tracing/upload/upload_code.py,sha256=XWRqVU_4kEgpPpx-TKmfgFFI5mxf_uO54yNhD5ogYNk,10170
 ragaai_catalyst/tracers/agentic_tracing/upload/upload_local_metric.py,sha256=m1O8lKpxKwtHofXLW3fTHX5yfqDW5GxoveARlg5cTw4,2571
@@ -64,7 +64,7 @@ ragaai_catalyst/tracers/agentic_tracing/utils/create_dataset_schema.py,sha256=Kx
 ragaai_catalyst/tracers/agentic_tracing/utils/file_name_tracker.py,sha256=YG601l1a29ov9VPu9Vl4RXxgL7l16k54_WWnoTNoG58,2064
 ragaai_catalyst/tracers/agentic_tracing/utils/generic.py,sha256=WwXT01xmp8MSr7KinuDCSK9a1ifpLcT7ajFkvYviG_A,1190
 ragaai_catalyst/tracers/agentic_tracing/utils/get_user_trace_metrics.py,sha256=vPZ4dn4EHFW0kqd1GyRpsYXbfrRrd0DXCmh-pzsDBNE,1109
-ragaai_catalyst/tracers/agentic_tracing/utils/llm_utils.py,sha256=Tdi4nnxsXywx-X-4FOvyzRpvB04rgyd3Mzf4o9k_BAI,22697
+ragaai_catalyst/tracers/agentic_tracing/utils/llm_utils.py,sha256=47kP4zdRTkJsOlvf5Cjx9Tayj6Ux_F21Ut7eJIgXgoE,22975
 ragaai_catalyst/tracers/agentic_tracing/utils/model_costs.json,sha256=2tzGw_cKCTPcfjEm7iGvFE6pTw7gMTPzeBov_MTaXNY,321336
 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
@@ -86,10 +86,10 @@ ragaai_catalyst/tracers/utils/langchain_tracer_extraction_logic.py,sha256=XS2_x2
 ragaai_catalyst/tracers/utils/model_prices_and_context_window_backup.json,sha256=C3uwkibJ08C9sOX-54kulZYmJlIpZ-SQpfE6HNGrjbM,343502
 ragaai_catalyst/tracers/utils/rag_extraction_logic_final.py,sha256=3ygkRT__lLDRflRttjzPu28tIA8cTCiGQVMQjqMItqQ,11309
 ragaai_catalyst/tracers/utils/rag_trace_json_converter.py,sha256=54IEZO-YRjUAahV5nw8KClXqTF1LhfDry_TsZ4KGow4,20467
-ragaai_catalyst/tracers/utils/trace_json_converter.py,sha256=YllXhkfyYOuQ0rsX9VqiUjMUeztDMs8TFMudIPkWvrY,10191
+ragaai_catalyst/tracers/utils/trace_json_converter.py,sha256=FV7oOWJkDQGjD9Td8sFCiCiQWk0tch6qZrTnp1lU6zU,11295
 ragaai_catalyst/tracers/utils/utils.py,sha256=L19LQGc8h08FFhyptBtixIHGG_e-VdSPsKs7JNaXnGE,2378
-ragaai_catalyst-2.2.2.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-ragaai_catalyst-2.2.2.dist-info/METADATA,sha256=2XcrTsdS1a_QyQyy5qa0dnxSBdKudwn62leYQNx0Udo,17677
-ragaai_catalyst-2.2.2.dist-info/WHEEL,sha256=zaaOINJESkSfm_4HQVc5ssNzHCPXhJm0kEUakpsEHaU,91
-ragaai_catalyst-2.2.2.dist-info/top_level.txt,sha256=HpgsdRgEJMk8nqrU6qdCYk3di7MJkDL0B19lkc7dLfM,16
-ragaai_catalyst-2.2.2.dist-info/RECORD,,
+ragaai_catalyst-2.2.3b0.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+ragaai_catalyst-2.2.3b0.dist-info/METADATA,sha256=D6E3L2zMZWn-IR_4NFDsOgVOKvmGSWo_NUMhY7U84Yw,17679
+ragaai_catalyst-2.2.3b0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+ragaai_catalyst-2.2.3b0.dist-info/top_level.txt,sha256=HpgsdRgEJMk8nqrU6qdCYk3di7MJkDL0B19lkc7dLfM,16
+ragaai_catalyst-2.2.3b0.dist-info/RECORD,,

{ragaai_catalyst-2.2.2.dist-info → ragaai_catalyst-2.2.3b0.dist-info}/WHEEL

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