openlit 1.34.26__py3-none-any.whl → 1.34.28__py3-none-any.whl

openlit/__helpers.py

@@ -469,6 +469,44 @@ def common_db_span_attributes(scope, db_system, server_address, server_port,
     scope._span.set_attribute(SERVICE_NAME, application_name)
     scope._span.set_attribute(SemanticConvention.DB_SDK_VERSION, version)
 
+def common_framework_span_attributes(scope, framework_system, server_address, server_port,
+    environment, application_name, version, endpoint, instance=None):
+    """
+    Set common span attributes for GenAI framework operations.
+    """
+
+    scope._span.set_attribute(TELEMETRY_SDK_NAME, "openlit")
+    scope._span.set_attribute(SemanticConvention.GEN_AI_SDK_VERSION, version)
+    scope._span.set_attribute(SemanticConvention.GEN_AI_SYSTEM, framework_system)
+    scope._span.set_attribute(SemanticConvention.GEN_AI_OPERATION, endpoint)
+    scope._span.set_attribute(SemanticConvention.GEN_AI_REQUEST_MODEL,
+        getattr(instance, "model_name", "unknown") if instance else "unknown")
+    scope._span.set_attribute(SemanticConvention.SERVER_ADDRESS, server_address)
+    scope._span.set_attribute(SemanticConvention.SERVER_PORT, server_port)
+    scope._span.set_attribute(DEPLOYMENT_ENVIRONMENT, environment)
+    scope._span.set_attribute(SERVICE_NAME, application_name)
+    scope._span.set_attribute(SemanticConvention.GEN_AI_CLIENT_OPERATION_DURATION,
+        scope._end_time - scope._start_time)
+
+def record_framework_metrics(metrics, gen_ai_operation, gen_ai_system, server_address, server_port,
+    environment, application_name, start_time, end_time):
+    """
+    Record basic framework metrics for the operation (only gen_ai_requests counter).
+    """
+
+    attributes = create_metrics_attributes(
+        operation=gen_ai_operation,
+        system=gen_ai_system,
+        server_address=server_address,
+        server_port=server_port,
+        request_model="unknown",
+        response_model="unknown",
+        service_name=application_name,
+        deployment_environment=environment,
+    )
+    metrics["genai_requests"].add(1, attributes)
+    metrics["genai_client_operation_duration"].record(end_time - start_time, attributes)
+
 def record_db_metrics(metrics, db_system, server_address, server_port,
     environment, application_name, start_time, end_time):
     """

openlit/__init__.py

@@ -13,7 +13,6 @@ from functools import wraps
 from contextlib import contextmanager
 import requests
 
-
 # Import internal modules for setting up tracing and fetching pricing info.
 from opentelemetry import trace as t
 from opentelemetry.trace import SpanKind, Status, StatusCode, Span
@@ -23,52 +22,12 @@ from openlit.otel.tracing import setup_tracing
 from openlit.otel.metrics import setup_meter
 from openlit.otel.events import setup_events
 from openlit.__helpers import fetch_pricing_info, get_env_variable
+from openlit._instrumentors import MODULE_NAME_MAP, get_all_instrumentors
 
-# Instrumentors for various large language models.
-from openlit.instrumentation.openai import OpenAIInstrumentor
-from openlit.instrumentation.anthropic import AnthropicInstrumentor
-from openlit.instrumentation.cohere import CohereInstrumentor
-from openlit.instrumentation.mistral import MistralInstrumentor
-from openlit.instrumentation.bedrock import BedrockInstrumentor
-from openlit.instrumentation.vertexai import VertexAIInstrumentor
-from openlit.instrumentation.groq import GroqInstrumentor
-from openlit.instrumentation.ollama import OllamaInstrumentor
-from openlit.instrumentation.gpt4all import GPT4AllInstrumentor
-from openlit.instrumentation.elevenlabs import ElevenLabsInstrumentor
-from openlit.instrumentation.vllm import VLLMInstrumentor
-from openlit.instrumentation.google_ai_studio import GoogleAIStudioInstrumentor
-from openlit.instrumentation.reka import RekaInstrumentor
-from openlit.instrumentation.premai import PremAIInstrumentor
-from openlit.instrumentation.assemblyai import AssemblyAIInstrumentor
-from openlit.instrumentation.azure_ai_inference import AzureAIInferenceInstrumentor
-from openlit.instrumentation.langchain import LangChainInstrumentor
-from openlit.instrumentation.langchain_community import LangChainCommunityInstrumentor
-from openlit.instrumentation.llamaindex import LlamaIndexInstrumentor
-from openlit.instrumentation.haystack import HaystackInstrumentor
-from openlit.instrumentation.embedchain import EmbedChainInstrumentor
-from openlit.instrumentation.mem0 import Mem0Instrumentor
-from openlit.instrumentation.chroma import ChromaInstrumentor
-from openlit.instrumentation.pinecone import PineconeInstrumentor
-from openlit.instrumentation.qdrant import QdrantInstrumentor
-from openlit.instrumentation.milvus import MilvusInstrumentor
-from openlit.instrumentation.astra import AstraInstrumentor
-from openlit.instrumentation.transformers import TransformersInstrumentor
-from openlit.instrumentation.litellm import LiteLLMInstrumentor
-from openlit.instrumentation.together import TogetherInstrumentor
-from openlit.instrumentation.crewai import CrewAIInstrumentor
-from openlit.instrumentation.ag2 import AG2Instrumentor
-from openlit.instrumentation.multion import MultiOnInstrumentor
-from openlit.instrumentation.dynamiq import DynamiqInstrumentor
-from openlit.instrumentation.phidata import PhidataInstrumentor
-from openlit.instrumentation.julep import JulepInstrumentor
-from openlit.instrumentation.ai21 import AI21Instrumentor
-from openlit.instrumentation.controlflow import ControlFlowInstrumentor
-from openlit.instrumentation.crawl4ai import Crawl4AIInstrumentor
-from openlit.instrumentation.firecrawl import FireCrawlInstrumentor
-from openlit.instrumentation.letta import LettaInstrumentor
-from openlit.instrumentation.openai_agents import OpenAIAgentsInstrumentor
-from openlit.instrumentation.pydantic_ai import PydanticAIInstrumentor
+# Import GPU instrumentor separately as it doesn't follow the standard pattern
 from openlit.instrumentation.gpu import GPUInstrumentor
+
+# Import guards and evals
 import openlit.guard
 import openlit.evals
 
@@ -93,6 +52,7 @@ class OpenlitConfig:
         otlp_headers (Optional[Dict[str, str]]): Headers for OTLP.
         disable_batch (bool): Flag to disable batch span processing in tracing.
         capture_message_content (bool): Flag to enable or disable tracing of content.
+        detailed_tracing (bool): Flag to enable detailed component-level tracing.
     """
 
     _instance = None
@@ -118,6 +78,7 @@ class OpenlitConfig:
         cls.disable_batch = False
         cls.capture_message_content = True
         cls.disable_metrics = False
+        cls.detailed_tracing = False
 
     @classmethod
     def update_config(
@@ -133,6 +94,7 @@ class OpenlitConfig:
         metrics_dict,
         disable_metrics,
         pricing_json,
+        detailed_tracing,
     ):
         """
         Updates the configuration based on provided parameters.
@@ -150,6 +112,7 @@ class OpenlitConfig:
             metrics_dict: Dictionary of metrics.
             disable_metrics (bool): Flag to disable metrics.
             pricing_json(str): path or url to the pricing json file
+            detailed_tracing (bool): Flag to enable detailed component-level tracing.
         """
         cls.environment = environment
         cls.application_name = application_name
@@ -162,6 +125,7 @@ class OpenlitConfig:
         cls.disable_batch = disable_batch
         cls.capture_message_content = capture_message_content
         cls.disable_metrics = disable_metrics
+        cls.detailed_tracing = detailed_tracing
 
 
 def module_exists(module_name):
@@ -173,20 +137,13 @@ def module_exists(module_name):
     return True
 
 
-def instrument_if_available(
-    instrumentor_name,
-    instrumentor_instance,
-    config,
-    disabled_instrumentors,
-    module_name_map,
-):
+def instrument_if_available(instrumentor_name, instrumentor_instance, config, disabled_instrumentors):
     """Instruments the specified instrumentor if its library is available."""
     if instrumentor_name in disabled_instrumentors:
         logger.info("Instrumentor %s is disabled", instrumentor_name)
         return
 
-    module_name = module_name_map.get(instrumentor_name)
-
+    module_name = MODULE_NAME_MAP.get(instrumentor_name)
     if not module_name:
         logger.error("No module mapping for %s", instrumentor_name)
         return
@@ -202,9 +159,9 @@ def instrument_if_available(
                 capture_message_content=config.capture_message_content,
                 metrics_dict=config.metrics_dict,
                 disable_metrics=config.disable_metrics,
+                detailed_tracing=config.detailed_tracing,
             )
         else:
-            # pylint: disable=line-too-long
             logger.info(
                 "Library for %s (%s) not found. Skipping instrumentation",
                 instrumentor_name,
@@ -228,6 +185,7 @@ def init(
     disable_metrics=False,
     pricing_json=None,
     collect_gpu_stats=False,
+    detailed_tracing=False,
 ):
     """
     Initializes the openLIT configuration and setups tracing.
@@ -249,60 +207,15 @@ def init(
         disable_metrics (bool): Flag to disable metrics (Optional).
         pricing_json(str): File path or url to the pricing json (Optional).
         collect_gpu_stats (bool): Flag to enable or disable GPU metrics collection.
+        detailed_tracing (bool): Enable detailed component-level tracing for debugging and optimization.
+                                Defaults to False to use workflow-level tracing with minimal storage overhead.
     """
     disabled_instrumentors = disabled_instrumentors if disabled_instrumentors else []
     logger.info("Starting openLIT initialization...")
 
-    module_name_map = {
-        "openai": "openai",
-        "anthropic": "anthropic",
-        "cohere": "cohere",
-        "mistral": "mistralai",
-        "bedrock": "boto3",
-        "vertexai": "vertexai",
-        "groq": "groq",
-        "ollama": "ollama",
-        "gpt4all": "gpt4all",
-        "elevenlabs": "elevenlabs",
-        "vllm": "vllm",
-        "google-ai-studio": "google.genai",
-        "azure-ai-inference": "azure.ai.inference",
-        "langchain": "langchain",
-        "langchain_community": "langchain_community",
-        "llama_index": "llama_index",
-        "haystack": "haystack",
-        "embedchain": "embedchain",
-        "mem0": "mem0",
-        "chroma": "chromadb",
-        "pinecone": "pinecone",
-        "qdrant": "qdrant_client",
-        "milvus": "pymilvus",
-        "transformers": "transformers",
-        "litellm": "litellm",
-        "crewai": "crewai",
-        "ag2": "ag2",
-        "autogen": "autogen",
-        "pyautogen": "pyautogen",
-        "multion": "multion",
-        "dynamiq": "dynamiq",
-        "phidata": "phi",
-        "reka-api": "reka",
-        "premai": "premai",
-        "julep": "julep",
-        "astra": "astrapy",
-        "ai21": "ai21",
-        "controlflow": "controlflow",
-        "assemblyai": "assemblyai",
-        "crawl4ai": "crawl4ai",
-        "firecrawl": "firecrawl",
-        "letta": "letta",
-        "together": "together",
-        "openai-agents": "agents",
-        "pydantic_ai": "pydantic_ai"
-    }
-
+    # Validate disabled instrumentors
     invalid_instrumentors = [
-        name for name in disabled_instrumentors if name not in module_name_map
+        name for name in disabled_instrumentors if name not in MODULE_NAME_MAP
     ]
     for invalid_name in invalid_instrumentors:
         logger.warning(
@@ -371,63 +284,17 @@ def init(
             metrics_dict,
             disable_metrics,
             pricing_json,
+            detailed_tracing,
         )
 
-        # Map instrumentor names to their instances
-        instrumentor_instances = {
-            "openai": OpenAIInstrumentor(),
-            "anthropic": AnthropicInstrumentor(),
-            "cohere": CohereInstrumentor(),
-            "mistral": MistralInstrumentor(),
-            "bedrock": BedrockInstrumentor(),
-            "vertexai": VertexAIInstrumentor(),
-            "groq": GroqInstrumentor(),
-            "ollama": OllamaInstrumentor(),
-            "gpt4all": GPT4AllInstrumentor(),
-            "elevenlabs": ElevenLabsInstrumentor(),
-            "vllm": VLLMInstrumentor(),
-            "google-ai-studio": GoogleAIStudioInstrumentor(),
-            "azure-ai-inference": AzureAIInferenceInstrumentor(),
-            "langchain": LangChainInstrumentor(),
-            "langchain_community": LangChainCommunityInstrumentor(),
-            "llama_index": LlamaIndexInstrumentor(),
-            "haystack": HaystackInstrumentor(),
-            "embedchain": EmbedChainInstrumentor(),
-            "mem0": Mem0Instrumentor(),
-            "chroma": ChromaInstrumentor(),
-            "pinecone": PineconeInstrumentor(),
-            "qdrant": QdrantInstrumentor(),
-            "milvus": MilvusInstrumentor(),
-            "transformers": TransformersInstrumentor(),
-            "litellm": LiteLLMInstrumentor(),
-            "crewai": CrewAIInstrumentor(),
-            "ag2": AG2Instrumentor(),
-            "multion": MultiOnInstrumentor(),
-            "autogen": AG2Instrumentor(),
-            "pyautogen": AG2Instrumentor(),
-            "dynamiq": DynamiqInstrumentor(),
-            "phidata": PhidataInstrumentor(),
-            "reka-api": RekaInstrumentor(),
-            "premai": PremAIInstrumentor(),
-            "julep": JulepInstrumentor(),
-            "astra": AstraInstrumentor(),
-            "ai21": AI21Instrumentor(),
-            "controlflow": ControlFlowInstrumentor(),
-            "assemblyai": AssemblyAIInstrumentor(),
-            "crawl4ai": Crawl4AIInstrumentor(),
-            "firecrawl": FireCrawlInstrumentor(),
-            "letta": LettaInstrumentor(),
-            "together": TogetherInstrumentor(),
-            "openai-agents": OpenAIAgentsInstrumentor(),
-            "pydantic_ai": PydanticAIInstrumentor(),
-        }
+        # Create instrumentor instances dynamically
+        instrumentor_instances = get_all_instrumentors()
 
         # Initialize and instrument only the enabled instrumentors
         for name, instrumentor in instrumentor_instances.items():
-            instrument_if_available(
-                name, instrumentor, config, disabled_instrumentors, module_name_map
-            )
+            instrument_if_available(name, instrumentor, config, disabled_instrumentors)
 
+        # Handle GPU instrumentation separately
         if not disable_metrics and collect_gpu_stats:
             GPUInstrumentor().instrument(
                 environment=config.environment,

openlit/_instrumentors.py

@@ -0,0 +1,144 @@
+"""
+OpenLIT Instrumentors
+"""
+import importlib
+
+# Mapping of instrumentor names to their required Python packages
+MODULE_NAME_MAP = {
+    "openai": "openai",
+    "anthropic": "anthropic",
+    "cohere": "cohere",
+    "mistral": "mistralai",
+    "bedrock": "boto3",
+    "vertexai": "vertexai",
+    "groq": "groq",
+    "ollama": "ollama",
+    "gpt4all": "gpt4all",
+    "elevenlabs": "elevenlabs",
+    "vllm": "vllm",
+    "google-ai-studio": "google.genai",
+    "azure-ai-inference": "azure.ai.inference",
+    "langchain": "langchain",
+    "langchain_community": "langchain_community",
+    "llama_index": "llama_index",
+    "haystack": "haystack",
+    "embedchain": "embedchain",
+    "mem0": "mem0",
+    "chroma": "chromadb",
+    "pinecone": "pinecone",
+    "qdrant": "qdrant_client",
+    "milvus": "pymilvus",
+    "transformers": "transformers",
+    "litellm": "litellm",
+    "crewai": "crewai",
+    "ag2": "ag2",
+    "autogen": "autogen",
+    "pyautogen": "pyautogen",
+    "multion": "multion",
+    "dynamiq": "dynamiq",
+    "phidata": "phi",
+    "reka-api": "reka",
+    "premai": "premai",
+    "julep": "julep",
+    "astra": "astrapy",
+    "ai21": "ai21",
+    "controlflow": "controlflow",
+    "assemblyai": "assemblyai",
+    "crawl4ai": "crawl4ai",
+    "firecrawl": "firecrawl",
+    "letta": "letta",
+    "together": "together",
+    "openai-agents": "agents",
+    "pydantic_ai": "pydantic_ai"
+}
+
+# Dictionary mapping instrumentor names to their full module paths
+INSTRUMENTOR_MAP = {
+    "openai": "openlit.instrumentation.openai.OpenAIInstrumentor",
+    "anthropic": "openlit.instrumentation.anthropic.AnthropicInstrumentor",
+    "cohere": "openlit.instrumentation.cohere.CohereInstrumentor",
+    "mistral": "openlit.instrumentation.mistral.MistralInstrumentor",
+    "bedrock": "openlit.instrumentation.bedrock.BedrockInstrumentor",
+    "vertexai": "openlit.instrumentation.vertexai.VertexAIInstrumentor",
+    "groq": "openlit.instrumentation.groq.GroqInstrumentor",
+    "ollama": "openlit.instrumentation.ollama.OllamaInstrumentor",
+    "gpt4all": "openlit.instrumentation.gpt4all.GPT4AllInstrumentor",
+    "elevenlabs": "openlit.instrumentation.elevenlabs.ElevenLabsInstrumentor",
+    "vllm": "openlit.instrumentation.vllm.VLLMInstrumentor",
+    "google-ai-studio": "openlit.instrumentation.google_ai_studio.GoogleAIStudioInstrumentor",
+    "azure-ai-inference": "openlit.instrumentation.azure_ai_inference.AzureAIInferenceInstrumentor",
+    "langchain": "openlit.instrumentation.langchain.LangChainInstrumentor",
+    "langchain_community": "openlit.instrumentation.langchain_community.LangChainCommunityInstrumentor",
+    "llama_index": "openlit.instrumentation.llamaindex.LlamaIndexInstrumentor",
+    "haystack": "openlit.instrumentation.haystack.HaystackInstrumentor",
+    "embedchain": "openlit.instrumentation.embedchain.EmbedChainInstrumentor",
+    "mem0": "openlit.instrumentation.mem0.Mem0Instrumentor",
+    "chroma": "openlit.instrumentation.chroma.ChromaInstrumentor",
+    "pinecone": "openlit.instrumentation.pinecone.PineconeInstrumentor",
+    "qdrant": "openlit.instrumentation.qdrant.QdrantInstrumentor",
+    "milvus": "openlit.instrumentation.milvus.MilvusInstrumentor",
+    "transformers": "openlit.instrumentation.transformers.TransformersInstrumentor",
+    "litellm": "openlit.instrumentation.litellm.LiteLLMInstrumentor",
+    "crewai": "openlit.instrumentation.crewai.CrewAIInstrumentor",
+    "ag2": "openlit.instrumentation.ag2.AG2Instrumentor",
+    "multion": "openlit.instrumentation.multion.MultiOnInstrumentor",
+    "autogen": "openlit.instrumentation.ag2.AG2Instrumentor",
+    "pyautogen": "openlit.instrumentation.ag2.AG2Instrumentor",
+    "dynamiq": "openlit.instrumentation.dynamiq.DynamiqInstrumentor",
+    "phidata": "openlit.instrumentation.phidata.PhidataInstrumentor",
+    "reka-api": "openlit.instrumentation.reka.RekaInstrumentor",
+    "premai": "openlit.instrumentation.premai.PremAIInstrumentor",
+    "julep": "openlit.instrumentation.julep.JulepInstrumentor",
+    "astra": "openlit.instrumentation.astra.AstraInstrumentor",
+    "ai21": "openlit.instrumentation.ai21.AI21Instrumentor",
+    "controlflow": "openlit.instrumentation.controlflow.ControlFlowInstrumentor",
+    "assemblyai": "openlit.instrumentation.assemblyai.AssemblyAIInstrumentor",
+    "crawl4ai": "openlit.instrumentation.crawl4ai.Crawl4AIInstrumentor",
+    "firecrawl": "openlit.instrumentation.firecrawl.FireCrawlInstrumentor",
+    "letta": "openlit.instrumentation.letta.LettaInstrumentor",
+    "together": "openlit.instrumentation.together.TogetherInstrumentor",
+    "openai-agents": "openlit.instrumentation.openai_agents.OpenAIAgentsInstrumentor",
+    "pydantic_ai": "openlit.instrumentation.pydantic_ai.PydanticAIInstrumentor",
+}
+
+
+def get_instrumentor_class(name):
+    """
+    Get instrumentor class by name.
+
+    Args:
+        name (str): Name of the instrumentor
+
+    Returns:
+        class: Instrumentor class or None if not found
+    """
+    if name not in INSTRUMENTOR_MAP:
+        return None
+
+    module_path, class_name = INSTRUMENTOR_MAP[name].rsplit(".", 1)
+
+    try:
+        module = importlib.import_module(module_path)
+        return getattr(module, class_name)
+    except (ImportError, AttributeError):
+        return None
+
+
+def get_all_instrumentors():
+    """
+    Get all available instrumentor instances.
+
+    Returns:
+        dict: Dictionary of instrumentor instances
+    """
+    instances = {}
+
+    for name in INSTRUMENTOR_MAP:
+        instrumentor_class = get_instrumentor_class(name)
+        if instrumentor_class:
+            try:
+                instances[name] = instrumentor_class()
+            except Exception:
+                pass  # Skip instrumentors that fail to instantiate
+
+    return instances

openlit/guard/all.py

@@ -75,7 +75,7 @@ def get_all_system_prompt(valid_topics: Optional[List[str]] = None, invalid_topi
 
     Output Instructions for Prompt Injection:
     - If no prompt injection commands are detected, return: {"score": 0.0, "verdict": "no", "guard": "prompt_injection", "classification": "none", "explanation": "none"}.
-    
+
     Categories of Valid Topics:
     """
 
@@ -103,7 +103,7 @@ def get_all_system_prompt(valid_topics: Optional[List[str]] = None, invalid_topi
     Output Instructions for Valid and Invalid Topics:
     - If the text fits into one of the valid categories, return: {"score": 0.0, "verdict": "no", "guard": "topic_restriction", "classification": "valid_topic", "explanation": "Fits a valid topic."}.
     - If the text fits into an invalid category, return: {"score": 1.0, "verdict": "yes", "guard": "topic_restriction", "classification": "invalid_topic", "explanation": "Matches an invalid topic."}.
-    
+
     Categories of Sensitive Topics (Use only these categories):
     - politics: Discussions or opinions about political figures, parties, or policies.
     - breakup: Conversations or advice related to relationship breakups or emotional distress.
@@ -120,7 +120,7 @@ def get_all_system_prompt(valid_topics: Optional[List[str]] = None, invalid_topi
         base_prompt += f"\n    Additional Sensitive Topics Categories:\n{custom_categories_str}"
 
     base_prompt += """
-    
+
     Output Instructions for Sensitive Topics:
     - If no sensitive topics are detected, return: {"score": 0.0, "verdict": "no", "guard": "sensitive_topic", "classification": "none", "explanation": "none"}.
     """