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

ragaai_catalyst/tracers/exporters/dynamic_trace_exporter.py

@@ -76,14 +76,14 @@ class DynamicTraceExporter(SpanExporter):
             # Update the exporter's properties
             self._update_exporter_properties()
         except Exception as e:
-            raise Exception(f"Error updating exporter properties: {e}")
+            logger.error(f"Error updating exporter properties: {e}")
 
         try:
             # Forward the call to the underlying exporter
             result = self._exporter.export(spans)
             return result
         except Exception as e:
-            raise Exception(f"Error exporting trace: {e}")
+            logger.error(f"Error exporting trace: {e}")
             
 
 
@@ -96,13 +96,13 @@ class DynamicTraceExporter(SpanExporter):
             # Update the exporter's properties
             self._update_exporter_properties()
         except Exception as e:
-            raise Exception(f"Error updating exporter properties: {e}")
+            logger.error(f"Error updating exporter properties: {e}")
 
         try:
             # Forward the call to the underlying exporter
             return self._exporter.shutdown()
         except Exception as e:
-            raise Exception(f"Error shutting down exporter: {e}")
+            logger.error(f"Error shutting down exporter: {e}")
     
     def _update_exporter_properties(self):
         """

ragaai_catalyst/tracers/exporters/file_span_exporter.py

@@ -136,9 +136,7 @@ class FileSpanExporter(SpanExporter):
         """
         async with aiohttp.ClientSession() as session:
             if not os.getenv("RAGAAI_CATALYST_TOKEN"):
-                raise ValueError(
-                    "RAGAAI_CATALYST_TOKEN not found. Cannot upload traces."
-                )
+                logger.error("RAGAAI_CATALYST_TOKEN not found. Cannot upload traces.")
 
             try:
                 upload_stat = await self.raga_client.check_and_upload_files(

ragaai_catalyst/tracers/exporters/raga_exporter.py

@@ -60,7 +60,7 @@ class RagaExporter:
         self.secret_key = os.getenv("RAGAAI_CATALYST_SECRET_KEY")
         self.max_urls = 20
         if not self.access_key or not self.secret_key:
-            raise ValueError(
+            logger.error(
                 "RAGAAI_CATALYST_ACCESS_KEY and RAGAAI_CATALYST_SECRET_KEY environment variables must be set"
             )
         if not os.getenv("RAGAAI_CATALYST_TOKEN"):
@@ -68,7 +68,7 @@ class RagaExporter:
 
         create_status_code = self._create_schema()
         if create_status_code != 200:
-            raise Exception(
+            logger.error(
                 "Failed to create schema. Please consider raising an issue."
             )
         # elif status_code != 200:

ragaai_catalyst/tracers/exporters/ragaai_trace_exporter.py

@@ -51,7 +51,7 @@ class RAGATraceExporter(SpanExporter):
                 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")
+                    logger.error("Trace ID is None")
 
                 if trace_id not in self.trace_spans:
                     self.trace_spans[trace_id] = list()
@@ -63,11 +63,11 @@ class RAGATraceExporter(SpanExporter):
                     try:
                         self.process_complete_trace(trace, trace_id)
                     except Exception as e:
-                        raise Exception(f"Error processing complete trace: {e}")
+                        logger.error(f"Error processing complete trace: {e}")
                     try:
                         del self.trace_spans[trace_id]
                     except Exception as e:
-                        raise Exception(f"Error deleting trace: {e}")
+                        logger.error(f"Error deleting trace: {e}")
             except Exception as e:
                 logger.warning(f"Error processing span: {e}")
                 continue

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 = (
@@ -157,7 +166,7 @@ class Tracer(AgenticTracing):
                 project["name"] for project in response.json()["data"]["content"]
             ]
             if project_name not in project_list:
-                raise ValueError("Project not found. Please enter a valid project name")
+                logger.error("Project not found. Please enter a valid project name")
             
             self.project_id = [
                 project["id"] for project in response.json()["data"]["content"] if project["name"] == project_name
@@ -168,7 +177,6 @@ class Tracer(AgenticTracing):
 
         except requests.exceptions.RequestException as e:
             logger.error(f"Failed to retrieve projects list: {e}")
-            raise
 
         # if tracer_type == "langchain":
         #     instrumentors = []
@@ -191,16 +199,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 +214,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 +229,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 +242,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 +250,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 +258,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 +266,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 +274,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 +282,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 +290,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 +308,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 +329,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:
@@ -391,20 +365,23 @@ class Tracer(AgenticTracing):
                 "output_cost_per_million_token": 2.40
             })
         """
-        if not isinstance(cost_config, dict):
-            raise TypeError("cost_config must be a dictionary")
-
-        required_keys = {"model_name", "input_cost_per_million_token", "output_cost_per_million_token"}
-        if not all(key in cost_config for key in required_keys):
-            raise ValueError(f"cost_config must contain all required keys: {required_keys}")
-
-        model_name = cost_config["model_name"]
-        self.model_custom_cost[model_name] = {
-            "input_cost_per_token": float(cost_config["input_cost_per_million_token"])/ 1000000,
-            "output_cost_per_token": float(cost_config["output_cost_per_million_token"]) /1000000
-        }
-        self.dynamic_exporter.custom_model_cost = self.model_custom_cost
-        logger.info(f"Updated custom model cost for {model_name}: {self.model_custom_cost[model_name]}")
+        logger.info("DEPRECATED: The set_model_cost method is deprecated and will be removed in a future version. Custom model costs can now be configured directly through the RagaAI Catalyst Platform")
+        print("DEPRECATED: The set_model_cost method is deprecated and will be removed in a future version. Custom model costs can now be configured directly through the RagaAI Catalyst Platform")
+        # if not isinstance(cost_config, dict):
+        #     logger.error("cost_config must be a dictionary")
+
+        # required_keys = {"model_name", "input_cost_per_million_token", "output_cost_per_million_token"}
+        # if not all(key in cost_config for key in required_keys):
+        #     logger.error(f"cost_config must contain all required keys: {required_keys}")
+
+        # model_name = cost_config["model_name"]
+        # self.model_custom_cost[model_name] = {
+        #     "input_cost_per_token": float(cost_config["input_cost_per_million_token"])/ 1000000,
+        #     "output_cost_per_token": float(cost_config["output_cost_per_million_token"]) /1000000
+        # }
+        # self.dynamic_exporter.custom_model_cost = self.model_custom_cost
+        # logger.info(f"Updated custom model cost for {model_name}: {self.model_custom_cost[model_name]}")
+        return None
         
 
     def register_masking_function(self, masking_func):
@@ -425,7 +402,7 @@ class Tracer(AgenticTracing):
                     return value
         """
         if not callable(masking_func):
-            raise TypeError("masking_func must be a callable")
+            logger.error("masking_func must be a callable")
 
         def recursive_mask_values(obj, parent_key=None):
             """Apply masking to all values in nested structure."""
@@ -440,7 +417,11 @@ 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", "output.mime_type",
+                        "span_id", "trace_id"
                     }
                     # Apply masking only if the key is NOT in the excluded list
                     if parent_key and parent_key.lower() not in excluded_keys:
@@ -497,7 +478,7 @@ class Tracer(AgenticTracing):
                 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")
+            logger.error("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)
@@ -600,7 +581,7 @@ class Tracer(AgenticTracing):
             "llama_index": LlamaIndexInstrumentor,
         }
         if tracer_type not in instrumentors:
-            raise ValueError(f"Invalid tracer type: {tracer_type}")
+            logger.error(f"Invalid tracer type: {tracer_type}")
         return instrumentors[tracer_type]().get()
 
     @contextmanager
@@ -721,9 +702,7 @@ class Tracer(AgenticTracing):
         """
         async with aiohttp.ClientSession() as session:
             if not os.getenv("RAGAAI_CATALYST_TOKEN"):
-                raise ValueError(
-                    "RAGAAI_CATALYST_TOKEN not found. Cannot upload traces."
-                )
+                logger.error("RAGAAI_CATALYST_TOKEN not found. Cannot upload traces.")
 
             try:
                 upload_stat = await asyncio.wait_for(
@@ -807,7 +786,7 @@ class Tracer(AgenticTracing):
             AttributeError: If the tracer_type is not an agentic tracer or if the dynamic_exporter is not initialized.
         """
         if not self.tracer_type.startswith("agentic/") or not hasattr(self, "dynamic_exporter"):
-            raise AttributeError("This method is only available for agentic tracers with a dynamic exporter.")
+            logger.error("This method is only available for agentic tracers with a dynamic exporter.")
             
         for key, value in kwargs.items():
             if hasattr(self.dynamic_exporter, key):
@@ -825,10 +804,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()
@@ -877,7 +853,7 @@ class Tracer(AgenticTracing):
             AttributeError: If the tracer_type is not 'agentic/llamaindex' or if the dynamic_exporter is not initialized.
         """
         if not self.tracer_type.startswith("agentic/") or not hasattr(self, "dynamic_exporter"):
-            raise AttributeError("This method is only available for agentic tracers with a dynamic exporter.")
+            logger.error("This method is only available for agentic tracers with a dynamic exporter.")
             
         # Get the latest list of unique files
         list_of_unique_files = self.file_tracker.get_unique_files()