kalibr 1.2.6__py3-none-any.whl → 1.2.9__py3-none-any.whl

kalibr/instrumentation/anthropic_instr.py

@@ -3,8 +3,11 @@ Anthropic SDK Instrumentation
 
 Monkey-patches the Anthropic SDK to automatically emit OpenTelemetry spans
 for all message API calls.
+
+Thread-safe singleton pattern using double-checked locking.
 """
 
+import threading
 import time
 from functools import wraps
 from typing import Any, Dict, Optional
@@ -15,50 +18,34 @@ from .base import BaseCostAdapter, BaseInstrumentation
 
 
 class AnthropicCostAdapter(BaseCostAdapter):
-    """Cost calculation adapter for Anthropic models"""
-
-    # Pricing per 1K tokens (USD) - Updated November 2025
-    PRICING = {
-        # Claude 4 models
-        "claude-4-opus": {"input": 0.015, "output": 0.075},
-        "claude-4-sonnet": {"input": 0.003, "output": 0.015},
-        # Claude 3 models (Sonnet 4 is actually Claude 3.7)
-        "claude-sonnet-4": {"input": 0.003, "output": 0.015},
-        "claude-3-7-sonnet": {"input": 0.003, "output": 0.015},
-        "claude-3-5-sonnet": {"input": 0.003, "output": 0.015},
-        "claude-3-opus": {"input": 0.015, "output": 0.075},
-        "claude-3-sonnet": {"input": 0.003, "output": 0.015},
-        "claude-3-haiku": {"input": 0.00025, "output": 0.00125},
-        # Claude 2 models
-        "claude-2.1": {"input": 0.008, "output": 0.024},
-        "claude-2.0": {"input": 0.008, "output": 0.024},
-        "claude-instant-1.2": {"input": 0.0008, "output": 0.0024},
-    }
-
-    def calculate_cost(self, model: str, usage: Dict[str, int]) -> float:
-        """Calculate cost in USD for an Anthropic API call"""
-        # Normalize model name
-        base_model = model.lower()
+    """Cost calculation adapter for Anthropic models.
+    
+    Uses centralized pricing from kalibr.pricing module.
+    """
 
-        # Try exact match first
-        pricing = self.get_pricing(base_model)
+    def get_vendor_name(self) -> str:
+        """Return vendor name for Anthropic."""
+        return "anthropic"
 
-        # Try fuzzy matching for versioned models
-        if not pricing:
-            for known_model in self.PRICING.keys():
-                if known_model in base_model or base_model in known_model:
-                    pricing = self.PRICING[known_model]
-                    break
-
-        if not pricing:
-            # Default to Claude 3 Sonnet pricing if unknown
-            pricing = {"input": 0.003, "output": 0.015}
+    def calculate_cost(self, model: str, usage: Dict[str, int]) -> float:
+        """Calculate cost in USD for an Anthropic API call.
+        
+        Args:
+            model: Model identifier (e.g., "claude-3-opus", "claude-3-5-sonnet-20240620")
+            usage: Token usage dict with input_tokens and output_tokens
+            
+        Returns:
+            Cost in USD (rounded to 6 decimal places)
+        """
+        # Get pricing from centralized module (handles normalization)
+        pricing = self.get_pricing_for_model(model)
 
         input_tokens = usage.get("input_tokens", 0)
         output_tokens = usage.get("output_tokens", 0)
 
-        input_cost = (input_tokens / 1000) * pricing["input"]
-        output_cost = (output_tokens / 1000) * pricing["output"]
+        # Calculate cost (pricing is per 1M tokens)
+        input_cost = (input_tokens / 1_000_000) * pricing["input"]
+        output_cost = (output_tokens / 1_000_000) * pricing["output"]
 
         return round(input_cost + output_cost, 6)
 
@@ -262,13 +249,20 @@ class AnthropicInstrumentation(BaseInstrumentation):
 
 # Singleton instance
 _anthropic_instrumentation = None
+_anthropic_lock = threading.Lock()
 
 
 def get_instrumentation() -> AnthropicInstrumentation:
-    """Get or create the Anthropic instrumentation singleton"""
+    """Get or create the Anthropic instrumentation singleton.
+    
+    Thread-safe singleton pattern using double-checked locking.
+    """
     global _anthropic_instrumentation
     if _anthropic_instrumentation is None:
-        _anthropic_instrumentation = AnthropicInstrumentation()
+        with _anthropic_lock:
+            # Double-check inside lock to prevent race condition
+            if _anthropic_instrumentation is None:
+                _anthropic_instrumentation = AnthropicInstrumentation()
     return _anthropic_instrumentation
 
 

kalibr/instrumentation/base.py

@@ -3,6 +3,8 @@ Base instrumentation class for LLM SDKs
 
 Provides common functionality for monkey-patching LLM SDKs and
 emitting OpenTelemetry-compatible spans.
+
+Note: Cost adapters now use centralized pricing from kalibr.pricing module.
 """
 
 import time
@@ -13,6 +15,8 @@ from typing import Any, Dict, Optional
 from opentelemetry import trace
 from opentelemetry.trace import SpanKind, Status, StatusCode
 
+from kalibr.pricing import get_pricing
+
 
 class BaseInstrumentation(ABC):
     """Base class for LLM SDK instrumentation"""
@@ -76,9 +80,11 @@ class BaseInstrumentation(ABC):
 
 
 class BaseCostAdapter(ABC):
-    """Base class for cost calculation adapters"""
-
-    PRICING: Dict[str, Dict[str, float]] = {}
+    """Base class for cost calculation adapters.
+    
+    Uses centralized pricing from kalibr.pricing module.
+    All subclasses must implement get_vendor_name() to specify their vendor.
+    """
 
     @abstractmethod
     def calculate_cost(self, model: str, usage: Dict[str, int]) -> float:
@@ -87,22 +93,34 @@ class BaseCostAdapter(ABC):
 
         Args:
             model: Model identifier (e.g., "gpt-4")
-            usage: Token usage dictionary with prompt_tokens, completion_tokens
+            usage: Token usage dictionary with prompt_tokens, completion_tokens,
+                   input_tokens, or output_tokens
 
         Returns:
             Cost in USD (rounded to 6 decimal places)
         """
         pass
 
-    def get_pricing(self, model: str) -> Optional[Dict[str, float]]:
+    @abstractmethod
+    def get_vendor_name(self) -> str:
+        """
+        Get the vendor name for this adapter.
+        
+        Returns:
+            Vendor name (e.g., "openai", "anthropic", "google")
+        """
+        pass
+
+    def get_pricing_for_model(self, model: str) -> Dict[str, float]:
         """
-        Get pricing for a specific model
+        Get pricing for a specific model using centralized pricing.
 
         Args:
             model: Model identifier
 
         Returns:
-            Dictionary with "input" and "output" prices per 1K tokens,
-            or None if model not found
+            Dictionary with "input" and "output" prices per 1M tokens
         """
-        return self.PRICING.get(model)
+        vendor = self.get_vendor_name()
+        pricing, _ = get_pricing(vendor, model)
+        return pricing

kalibr/instrumentation/google_instr.py

@@ -3,8 +3,11 @@ Google Generative AI SDK Instrumentation
 
 Monkey-patches the Google Generative AI SDK to automatically emit OpenTelemetry spans
 for all content generation API calls.
+
+Thread-safe singleton pattern using double-checked locking.
 """
 
+import threading
 import time
 from functools import wraps
 from typing import Any, Dict, Optional
@@ -15,49 +18,34 @@ from .base import BaseCostAdapter, BaseInstrumentation
 
 
 class GoogleCostAdapter(BaseCostAdapter):
-    """Cost calculation adapter for Google Generative AI models"""
-
-    # Pricing per 1K tokens (USD) - Updated November 2025
-    PRICING = {
-        # Gemini 2.5 models
-        "gemini-2.5-pro": {"input": 0.00125, "output": 0.005},
-        "gemini-2.5-flash": {"input": 0.000075, "output": 0.0003},
-        # Gemini 2.0 models
-        "gemini-2.0-flash": {"input": 0.000075, "output": 0.0003},
-        "gemini-2.0-flash-thinking": {"input": 0.000075, "output": 0.0003},
-        # Gemini 1.5 models
-        "gemini-1.5-pro": {"input": 0.00125, "output": 0.005},
-        "gemini-1.5-flash": {"input": 0.000075, "output": 0.0003},
-        "gemini-1.5-flash-8b": {"input": 0.0000375, "output": 0.00015},
-        # Gemini 1.0 models
-        "gemini-1.0-pro": {"input": 0.0005, "output": 0.0015},
-        "gemini-pro": {"input": 0.0005, "output": 0.0015},  # Alias
-    }
-
-    def calculate_cost(self, model: str, usage: Dict[str, int]) -> float:
-        """Calculate cost in USD for a Google Generative AI API call"""
-        # Normalize model name
-        base_model = model.lower()
+    """Cost calculation adapter for Google Generative AI models.
+    
+    Uses centralized pricing from kalibr.pricing module.
+    """
 
-        # Try exact match first
-        pricing = self.get_pricing(base_model)
+    def get_vendor_name(self) -> str:
+        """Return vendor name for Google."""
+        return "google"
 
-        # Try fuzzy matching for versioned models
-        if not pricing:
-            for known_model in self.PRICING.keys():
-                if known_model in base_model or base_model in known_model:
-                    pricing = self.PRICING[known_model]
-                    break
-
-        if not pricing:
-            # Default to Gemini 1.5 Pro pricing if unknown
-            pricing = {"input": 0.00125, "output": 0.005}
+    def calculate_cost(self, model: str, usage: Dict[str, int]) -> float:
+        """Calculate cost in USD for a Google Generative AI API call.
+        
+        Args:
+            model: Model identifier (e.g., "gemini-1.5-pro", "gemini-2.0-flash")
+            usage: Token usage dict with prompt_tokens and completion_tokens
+            
+        Returns:
+            Cost in USD (rounded to 6 decimal places)
+        """
+        # Get pricing from centralized module (handles normalization)
+        pricing = self.get_pricing_for_model(model)
 
         prompt_tokens = usage.get("prompt_tokens", 0)
         completion_tokens = usage.get("completion_tokens", 0)
 
-        input_cost = (prompt_tokens / 1000) * pricing["input"]
-        output_cost = (completion_tokens / 1000) * pricing["output"]
+        # Calculate cost (pricing is per 1M tokens)
+        input_cost = (prompt_tokens / 1_000_000) * pricing["input"]
+        output_cost = (completion_tokens / 1_000_000) * pricing["output"]
 
         return round(input_cost + output_cost, 6)
 
@@ -261,13 +249,20 @@ class GoogleInstrumentation(BaseInstrumentation):
 
 # Singleton instance
 _google_instrumentation = None
+_google_lock = threading.Lock()
 
 
 def get_instrumentation() -> GoogleInstrumentation:
-    """Get or create the Google instrumentation singleton"""
+    """Get or create the Google instrumentation singleton.
+    
+    Thread-safe singleton pattern using double-checked locking.
+    """
     global _google_instrumentation
     if _google_instrumentation is None:
-        _google_instrumentation = GoogleInstrumentation()
+        with _google_lock:
+            # Double-check inside lock to prevent race condition
+            if _google_instrumentation is None:
+                _google_instrumentation = GoogleInstrumentation()
     return _google_instrumentation
 
 

kalibr/instrumentation/openai_instr.py

@@ -3,8 +3,11 @@ OpenAI SDK Instrumentation
 
 Monkey-patches the OpenAI SDK to automatically emit OpenTelemetry spans
 for all chat completion API calls.
+
+Thread-safe singleton pattern using double-checked locking.
 """
 
+import threading
 import time
 from functools import wraps
 from typing import Any, Dict, Optional
@@ -15,38 +18,34 @@ from .base import BaseCostAdapter, BaseInstrumentation
 
 
 class OpenAICostAdapter(BaseCostAdapter):
-    """Cost calculation adapter for OpenAI models"""
-
-    # Pricing per 1K tokens (USD) - Updated November 2025
-    PRICING = {
-        # GPT-5 models
-        "gpt-5": {"input": 0.005, "output": 0.015},
-        "gpt-5-turbo": {"input": 0.0025, "output": 0.0075},
-        # GPT-4 models
-        "gpt-4": {"input": 0.03, "output": 0.06},
-        "gpt-4-turbo": {"input": 0.01, "output": 0.03},
-        "gpt-4o": {"input": 0.0025, "output": 0.01},
-        "gpt-4o-mini": {"input": 0.00015, "output": 0.0006},
-        # GPT-3.5 models
-        "gpt-3.5-turbo": {"input": 0.0005, "output": 0.0015},
-        "gpt-3.5-turbo-16k": {"input": 0.001, "output": 0.002},
-    }
+    """Cost calculation adapter for OpenAI models.
+    
+    Uses centralized pricing from kalibr.pricing module.
+    """
 
-    def calculate_cost(self, model: str, usage: Dict[str, int]) -> float:
-        """Calculate cost in USD for an OpenAI API call"""
-        # Normalize model name (remove version suffixes)
-        base_model = model.split("-2")[0]  # Remove date suffixes like -20240101
+    def get_vendor_name(self) -> str:
+        """Return vendor name for OpenAI."""
+        return "openai"
 
-        pricing = self.get_pricing(base_model)
-        if not pricing:
-            # Default to GPT-4 pricing if unknown
-            pricing = {"input": 0.03, "output": 0.06}
+    def calculate_cost(self, model: str, usage: Dict[str, int]) -> float:
+        """Calculate cost in USD for an OpenAI API call.
+        
+        Args:
+            model: Model identifier (e.g., "gpt-4o", "gpt-4o-2024-05-13")
+            usage: Token usage dict with prompt_tokens and completion_tokens
+            
+        Returns:
+            Cost in USD (rounded to 6 decimal places)
+        """
+        # Get pricing from centralized module (handles normalization)
+        pricing = self.get_pricing_for_model(model)
 
         prompt_tokens = usage.get("prompt_tokens", 0)
         completion_tokens = usage.get("completion_tokens", 0)
 
-        input_cost = (prompt_tokens / 1000) * pricing["input"]
-        output_cost = (completion_tokens / 1000) * pricing["output"]
+        # Calculate cost (pricing is per 1M tokens)
+        input_cost = (prompt_tokens / 1_000_000) * pricing["input"]
+        output_cost = (completion_tokens / 1_000_000) * pricing["output"]
 
         return round(input_cost + output_cost, 6)
 
@@ -245,13 +244,20 @@ class OpenAIInstrumentation(BaseInstrumentation):
 
 # Singleton instance
 _openai_instrumentation = None
+_openai_lock = threading.Lock()
 
 
 def get_instrumentation() -> OpenAIInstrumentation:
-    """Get or create the OpenAI instrumentation singleton"""
+    """Get or create the OpenAI instrumentation singleton.
+    
+    Thread-safe singleton pattern using double-checked locking.
+    """
     global _openai_instrumentation
     if _openai_instrumentation is None:
-        _openai_instrumentation = OpenAIInstrumentation()
+        with _openai_lock:
+            # Double-check inside lock to prevent race condition
+            if _openai_instrumentation is None:
+                _openai_instrumentation = OpenAIInstrumentation()
     return _openai_instrumentation
 
 

kalibr/instrumentation/registry.py

@@ -3,18 +3,25 @@ Instrumentation Registry
 
 Handles auto-discovery and registration of LLM SDK instrumentations.
 Provides a central place to manage which SDKs are instrumented.
+
+Thread-safe registry using locks to protect shared state.
 """
 
 import os
+import threading
 from typing import Dict, List, Set
 
 # Track which providers have been instrumented
 _instrumented_providers: Set[str] = set()
+# Lock to protect concurrent access to the registry
+_registry_lock = threading.Lock()
 
 
 def auto_instrument(providers: List[str] = None) -> Dict[str, bool]:
     """
     Auto-discover and instrument LLM SDKs
+    
+    Thread-safe: Uses internal lock to protect registry state.
 
     Args:
         providers: List of provider names to instrument.
@@ -35,10 +42,11 @@ def auto_instrument(providers: List[str] = None) -> Dict[str, bool]:
     for provider in providers:
         provider_lower = provider.lower()
 
-        # Skip if already instrumented
-        if provider_lower in _instrumented_providers:
-            results[provider_lower] = True
-            continue
+        # Check if already instrumented (thread-safe read)
+        with _registry_lock:
+            if provider_lower in _instrumented_providers:
+                results[provider_lower] = True
+                continue
 
         try:
             if provider_lower == "openai":
@@ -47,7 +55,8 @@ def auto_instrument(providers: List[str] = None) -> Dict[str, bool]:
                 success = openai_instr.instrument()
                 results[provider_lower] = success
                 if success:
-                    _instrumented_providers.add(provider_lower)
+                    with _registry_lock:
+                        _instrumented_providers.add(provider_lower)
                     print(f"✅ Instrumented OpenAI SDK")
 
             elif provider_lower == "anthropic":
@@ -56,7 +65,8 @@ def auto_instrument(providers: List[str] = None) -> Dict[str, bool]:
                 success = anthropic_instr.instrument()
                 results[provider_lower] = success
                 if success:
-                    _instrumented_providers.add(provider_lower)
+                    with _registry_lock:
+                        _instrumented_providers.add(provider_lower)
                     print(f"✅ Instrumented Anthropic SDK")
 
             elif provider_lower == "google":
@@ -65,7 +75,8 @@ def auto_instrument(providers: List[str] = None) -> Dict[str, bool]:
                 success = google_instr.instrument()
                 results[provider_lower] = success
                 if success:
-                    _instrumented_providers.add(provider_lower)
+                    with _registry_lock:
+                        _instrumented_providers.add(provider_lower)
                     print(f"✅ Instrumented Google Generative AI SDK")
 
             else:
@@ -85,6 +96,8 @@ def auto_instrument(providers: List[str] = None) -> Dict[str, bool]:
 def uninstrument_all() -> Dict[str, bool]:
     """
     Remove instrumentation from all previously instrumented SDKs
+    
+    Thread-safe: Uses internal lock to protect registry state.
 
     Returns:
         Dictionary mapping provider names to uninstrumentation success status
@@ -92,7 +105,10 @@ def uninstrument_all() -> Dict[str, bool]:
     global _instrumented_providers
 
     results = {}
-    providers_to_uninstrument = list(_instrumented_providers)
+    
+    # Get snapshot of providers to uninstrument (thread-safe)
+    with _registry_lock:
+        providers_to_uninstrument = list(_instrumented_providers)
 
     for provider in providers_to_uninstrument:
         try:
@@ -102,7 +118,8 @@ def uninstrument_all() -> Dict[str, bool]:
                 success = openai_instr.uninstrument()
                 results[provider] = success
                 if success:
-                    _instrumented_providers.discard(provider)
+                    with _registry_lock:
+                        _instrumented_providers.discard(provider)
                     print(f"✅ Uninstrumented OpenAI SDK")
 
             elif provider == "anthropic":
@@ -111,7 +128,8 @@ def uninstrument_all() -> Dict[str, bool]:
                 success = anthropic_instr.uninstrument()
                 results[provider] = success
                 if success:
-                    _instrumented_providers.discard(provider)
+                    with _registry_lock:
+                        _instrumented_providers.discard(provider)
                     print(f"✅ Uninstrumented Anthropic SDK")
 
             elif provider == "google":
@@ -120,7 +138,8 @@ def uninstrument_all() -> Dict[str, bool]:
                 success = google_instr.uninstrument()
                 results[provider] = success
                 if success:
-                    _instrumented_providers.discard(provider)
+                    with _registry_lock:
+                        _instrumented_providers.discard(provider)
                     print(f"✅ Uninstrumented Google Generative AI SDK")
 
         except Exception as e:
@@ -133,16 +152,21 @@ def uninstrument_all() -> Dict[str, bool]:
 def get_instrumented_providers() -> List[str]:
     """
     Get list of currently instrumented providers
+    
+    Thread-safe: Returns a snapshot of the current state.
 
     Returns:
         List of provider names that are currently instrumented
     """
-    return list(_instrumented_providers)
+    with _registry_lock:
+        return list(_instrumented_providers)
 
 
 def is_instrumented(provider: str) -> bool:
     """
     Check if a specific provider is instrumented
+    
+    Thread-safe: Protected by internal lock.
 
     Args:
         provider: Provider name to check
@@ -150,4 +174,5 @@ def is_instrumented(provider: str) -> bool:
     Returns:
         True if provider is instrumented, False otherwise
     """
-    return provider.lower() in _instrumented_providers
+    with _registry_lock:
+        return provider.lower() in _instrumented_providers

kalibr/intelligence.py

@@ -33,6 +33,7 @@ Example - Path registration and intelligent routing:
 from __future__ import annotations
 
 import os
+import threading
 from typing import Any, Optional
 
 import httpx
@@ -153,6 +154,7 @@ class KalibrIntelligence:
         metadata: dict | None = None,
         tool_id: str | None = None,
         execution_params: dict | None = None,
+        model_id: str | None = None,
     ) -> dict[str, Any]:
         """Report execution outcome for a goal.
 
@@ -202,6 +204,7 @@ class KalibrIntelligence:
                 "metadata": metadata,
                 "tool_id": tool_id,
                 "execution_params": execution_params,
+                "model_id": model_id,
             },
         )
         return response.json()
@@ -507,13 +510,20 @@ class KalibrIntelligence:
 
 # Module-level singleton for convenience functions
 _intelligence_client: KalibrIntelligence | None = None
+_client_lock = threading.Lock()
 
 
 def _get_intelligence_client() -> KalibrIntelligence:
-    """Get or create the singleton intelligence client."""
+    """Get or create the singleton intelligence client.
+    
+    Thread-safe singleton pattern using double-checked locking.
+    """
     global _intelligence_client
     if _intelligence_client is None:
-        _intelligence_client = KalibrIntelligence()
+        with _client_lock:
+            # Double-check inside lock to prevent race condition
+            if _intelligence_client is None:
+                _intelligence_client = KalibrIntelligence()
     return _intelligence_client
 
 
@@ -537,11 +547,11 @@ def get_policy(goal: str, tenant_id: str | None = None, **kwargs) -> dict[str, A
         policy = get_policy(goal="book_meeting")
         model = policy["recommended_model"]
     """
-    client = _get_intelligence_client()
     if tenant_id:
-        # Create a new client with the specified tenant_id
-        client = KalibrIntelligence(tenant_id=tenant_id)
-    return client.get_policy(goal, **kwargs)
+        # Use context manager to ensure client is properly closed
+        with KalibrIntelligence(tenant_id=tenant_id) as client:
+            return client.get_policy(goal, **kwargs)
+    return _get_intelligence_client().get_policy(goal, **kwargs)
 
 
 def report_outcome(trace_id: str, goal: str, success: bool, tenant_id: str | None = None, **kwargs) -> dict[str, Any]:
@@ -565,11 +575,11 @@ def report_outcome(trace_id: str, goal: str, success: bool, tenant_id: str | Non
 
         report_outcome(trace_id="abc123", goal="book_meeting", success=True)
     """
-    client = _get_intelligence_client()
     if tenant_id:
-        # Create a new client with the specified tenant_id
-        client = KalibrIntelligence(tenant_id=tenant_id)
-    return client.report_outcome(trace_id, goal, success, **kwargs)
+        # Use context manager to ensure client is properly closed
+        with KalibrIntelligence(tenant_id=tenant_id) as client:
+            return client.report_outcome(trace_id, goal, success, **kwargs)
+    return _get_intelligence_client().report_outcome(trace_id, goal, success, **kwargs)
 
 
 def get_recommendation(task_type: str, **kwargs) -> dict[str, Any]:
@@ -614,10 +624,11 @@ def register_path(
             tool_id="calendar_tool"
         )
     """
-    client = _get_intelligence_client()
     if tenant_id:
-        client = KalibrIntelligence(tenant_id=tenant_id)
-    return client.register_path(goal, model_id, tool_id, params, risk_level)
+        # Use context manager to ensure client is properly closed
+        with KalibrIntelligence(tenant_id=tenant_id) as client:
+            return client.register_path(goal, model_id, tool_id, params, risk_level)
+    return _get_intelligence_client().register_path(goal, model_id, tool_id, params, risk_level)
 
 
 def decide(
@@ -644,7 +655,8 @@ def decide(
         decision = decide(goal="book_meeting")
         model = decision["model_id"]
     """
-    client = _get_intelligence_client()
     if tenant_id:
-        client = KalibrIntelligence(tenant_id=tenant_id)
-    return client.decide(goal, task_risk_level)
+        # Use context manager to ensure client is properly closed
+        with KalibrIntelligence(tenant_id=tenant_id) as client:
+            return client.decide(goal, task_risk_level)
+    return _get_intelligence_client().decide(goal, task_risk_level)

kalibr/middleware/auto_tracer.py

@@ -54,7 +54,7 @@ class AutoTracerMiddleware(BaseHTTPMiddleware):
 
         # Collector config
         self.collector_url = collector_url or os.getenv(
-            "KALIBR_COLLECTOR_URL", "https://api.kalibr.systems/api/ingest"
+            "KALIBR_COLLECTOR_URL", "https://kalibr-backend.fly.dev/api/ingest"
         )
         self.api_key = api_key or os.getenv("KALIBR_API_KEY", "")
         self.tenant_id = tenant_id or os.getenv("KALIBR_TENANT_ID", "default")