lucidicai 2.0.1__py3-none-any.whl → 2.1.0__py3-none-any.whl

lucidicai/telemetry/lucidic_exporter.py

@@ -4,7 +4,6 @@ Converts completed spans into immutable typed LLM events via Client.create_event
 which enqueues non-blocking delivery through the EventQueue.
 """
 import json
-import logging
 from typing import Sequence, Optional, Dict, Any, List
 from datetime import datetime, timezone
 from opentelemetry.sdk.trace import ReadableSpan
@@ -12,16 +11,12 @@ from opentelemetry.sdk.trace.export import SpanExporter, SpanExportResult
 from opentelemetry.trace import StatusCode
 from opentelemetry.semconv_ai import SpanAttributes
 
-from lucidicai.client import Client
-from lucidicai.context import current_session_id, current_parent_event_id
-from lucidicai.model_pricing import calculate_cost
+from ..sdk.event import create_event
+from ..sdk.init import get_session_id
+from ..sdk.context import current_session_id, current_parent_event_id
+from ..telemetry.utils.model_pricing import calculate_cost
 from .extract import detect_is_llm_span, extract_images, extract_prompts, extract_completions, extract_model
-
-logger = logging.getLogger("Lucidic")
-import os
-
-DEBUG = os.getenv("LUCIDIC_DEBUG", "False") == "True"
-VERBOSE = os.getenv("LUCIDIC_VERBOSE", "False") == "True"
+from ..utils.logger import debug, info, warning, error, verbose, truncate_id
 
 
 class LucidicSpanExporter(SpanExporter):
@@ -29,23 +24,25 @@ class LucidicSpanExporter(SpanExporter):
 
     def export(self, spans: Sequence[ReadableSpan]) -> SpanExportResult:
         try:
-            client = Client()
-            if DEBUG and spans:
-                logger.debug(f"[LucidicSpanExporter] Processing {len(spans)} spans")
+            if spans:
+                debug(f"[Telemetry] Processing {len(spans)} OpenTelemetry spans")
             for span in spans:
-                self._process_span(span, client)
-            if DEBUG and spans:
-                logger.debug(f"[LucidicSpanExporter] Successfully exported {len(spans)} spans")
+                self._process_span(span)
+            if spans:
+                debug(f"[Telemetry] Successfully exported {len(spans)} spans")
             return SpanExportResult.SUCCESS
         except Exception as e:
-            logger.error(f"Failed to export spans: {e}")
+            error(f"[Telemetry] Failed to export spans: {e}")
             return SpanExportResult.FAILURE
 
-    def _process_span(self, span: ReadableSpan, client: Client) -> None:
+    def _process_span(self, span: ReadableSpan) -> None:
         """Convert a single LLM span into a typed, immutable event."""
         try:
             if not detect_is_llm_span(span):
+                verbose(f"[Telemetry] Skipping non-LLM span: {span.name}")
                 return
+            
+            debug(f"[Telemetry] Processing LLM span: {span.name}")
 
             attributes = dict(span.attributes or {})
 
@@ -56,22 +53,30 @@ class LucidicSpanExporter(SpanExporter):
                     target_session_id = current_session_id.get(None)
                 except Exception:
                     target_session_id = None
-            if not target_session_id and getattr(client, 'session', None) and getattr(client.session, 'session_id', None):
-                target_session_id = client.session.session_id
             if not target_session_id:
+                target_session_id = get_session_id()
+            if not target_session_id:
+                debug(f"[Telemetry] No session ID for span {span.name}, skipping")
                 return
 
             # Parent nesting - get from span attributes (captured at span creation)
             parent_id = attributes.get('lucidic.parent_event_id')
+            debug(f"[Telemetry] Span {span.name} has parent_id from attributes: {truncate_id(parent_id)}")
             if not parent_id:
                 # Fallback to trying context (may work if same thread)
                 try:
                     parent_id = current_parent_event_id.get(None)
+                    if parent_id:
+                        debug(f"[Telemetry] Got parent_id from context for span {span.name}: {truncate_id(parent_id)}")
                 except Exception:
                     parent_id = None
+            
+            if not parent_id:
+                debug(f"[Telemetry] No parent_id available for span {span.name}")
 
             # Timing
-            occurred_at = datetime.fromtimestamp(span.start_time / 1_000_000_000, tz=timezone.utc) if span.start_time else datetime.now(tz=timezone.utc)
+            occurred_at_dt = datetime.fromtimestamp(span.start_time / 1_000_000_000, tz=timezone.utc) if span.start_time else datetime.now(tz=timezone.utc)
+            occurred_at = occurred_at_dt.isoformat()  # Convert to ISO string for JSON serialization
             duration_seconds = ((span.end_time - span.start_time) / 1_000_000_000) if (span.start_time and span.end_time) else None
 
             # Typed fields using extract utilities
@@ -85,11 +90,18 @@ class LucidicSpanExporter(SpanExporter):
             cost = self._calculate_cost(attributes)
             images = extract_images(attributes)
 
-            # Create immutable event via non-blocking queue
-            event_id = client.create_event(
+            # Set context for parent if needed
+            from ..sdk.context import current_parent_event_id as parent_context
+            if parent_id:
+                token = parent_context.set(parent_id)
+            else:
+                token = None
+            
+            try:
+                # Create immutable event via non-blocking queue
+                debug(f"[Telemetry] Creating LLM event with parent_id: {truncate_id(parent_id)}")
+                event_id = create_event(
                 type="llm_generation",
-                session_id=target_session_id,
-                parent_event_id=parent_id,
                 occurred_at=occurred_at,
                 duration=duration_seconds,
                 provider=provider,
@@ -101,16 +113,20 @@ class LucidicSpanExporter(SpanExporter):
                 output_tokens=output_tokens,
                 cost=cost,
                 raw={"images": images} if images else None,
+                parent_event_id=parent_id,  # Pass the parent_id explicitly
             )
+            finally:
+                # Reset parent context
+                if token:
+                    parent_context.reset(token)
             
-            if DEBUG:
-                logger.debug(f"[LucidicSpanExporter] Created LLM event {event_id} for session {target_session_id[:8]}...")
+            debug(f"[Telemetry] Created LLM event {truncate_id(event_id)} from span {span.name} for session {truncate_id(target_session_id)}")
 
         except Exception as e:
-            logger.error(f"Failed to process span {span.name}: {e}")
+            error(f"[Telemetry] Failed to process span {span.name}: {e}")
     
     
-    def _create_event_from_span(self, span: ReadableSpan, attributes: Dict[str, Any], client: Client) -> Optional[str]:
+    def _create_event_from_span(self, span: ReadableSpan, attributes: Dict[str, Any]) -> Optional[str]:
         """Create a Lucidic event from span start"""
         try:
             # Extract description from prompts/messages
@@ -132,9 +148,9 @@ class LucidicSpanExporter(SpanExporter):
                 except Exception:
                     target_session_id = None
             if not target_session_id:
-                if getattr(client, 'session', None) and getattr(client.session, 'session_id', None):
-                    target_session_id = client.session.session_id
+                target_session_id = get_session_id()
             if not target_session_id:
+                debug(f"[Telemetry] No session ID for span {span.name}, skipping")
                 return None
 
             # Create event
@@ -147,13 +163,13 @@ class LucidicSpanExporter(SpanExporter):
             if images:
                 event_kwargs['screenshots'] = images
                 
-            return client.create_event_for_session(target_session_id, **event_kwargs)
+            return create_event(**event_kwargs)
             
         except Exception as e:
-            logger.error(f"Failed to create event from span: {e}")
+            error(f"[Telemetry] Failed to create event from span: {e}")
             return None
     
-    def _update_event_from_span(self, span: ReadableSpan, attributes: Dict[str, Any], event_id: str, client: Client) -> None:
+    def _update_event_from_span(self, span: ReadableSpan, attributes: Dict[str, Any], event_id: str) -> None:
         """Deprecated: events are immutable; no updates performed."""
         return
     
@@ -163,8 +179,7 @@ class LucidicSpanExporter(SpanExporter):
         prompts = attributes.get(SpanAttributes.LLM_PROMPTS) or \
                  attributes.get('gen_ai.prompt')
         
-        if VERBOSE:
-            logger.info(f"[SpaneExporter -- DEBUG] Extracting Description attributes: {attributes}, prompts: {prompts}")
+        verbose(f"[Telemetry] Extracting description from attributes: {attributes}, prompts: {prompts}")
 
         if prompts:
             if isinstance(prompts, list) and prompts:

lucidicai/telemetry/utils/model_pricing.py

@@ -0,0 +1,278 @@
+import logging
+
+logger = logging.getLogger("Lucidic")
+
+MODEL_PRICING = {
+
+    # OpenAI GPT-5 Series (Verified 2025)
+    "gpt-5": {"input": 10.0, "output": 10.0},
+    "gpt-5-mini": {"input": 0.250, "output": 2.0},
+    "gpt-5-nano": {"input": 0.05, "output": 0.4},
+
+    # OpenAI GPT-4o Series (Verified 2025)
+    "gpt-4o": {"input": 2.5, "output": 10.0},
+    "gpt-4o-mini": {"input": 0.15, "output": 0.6},
+    "gpt-4o-realtime-preview": {"input": 5.0, "output": 20.0},  # Text pricing
+    "gpt-4o-audio-preview": {"input": 100.0, "output": 200.0},  # Audio pricing per 1M tokens
+    
+    # OpenAI GPT-4.1 Series (2025)
+    "gpt-4.1": {"input": 2.00, "output": 8.0},
+    "gpt-4.1-mini": {"input": 0.4, "output": 1.6},
+    "gpt-4.1-nano": {"input": 0.2, "output": 0.8},
+    
+    # OpenAI GPT-4 Series
+    "gpt-4": {"input": 30.0, "output": 60.0},
+    "gpt-4-turbo": {"input": 10.0, "output": 30.0},
+    "gpt-4-turbo-preview": {"input": 10.0, "output": 30.0},
+    "gpt-4-vision-preview": {"input": 10.0, "output": 30.0},
+    "gpt-4-32k": {"input": 60.0, "output": 120.0},
+    
+    # OpenAI GPT-3.5 Series
+    "gpt-3.5-turbo": {"input": 0.5, "output": 1.5},
+    "gpt-3.5-turbo-16k": {"input": 3.0, "output": 4.0},
+    "gpt-3.5-turbo-instruct": {"input": 1.5, "output": 2.0},
+    
+    # OpenAI o-Series (Reasoning Models) - Verified 2025
+    "o1": {"input": 15.0, "output": 60.0},
+    "o1-preview": {"input": 15.0, "output": 60.0},
+    "o1-mini": {"input": 3.0, "output": 15.0}, 
+    "o3": {"input": 15.0, "output": 60.0}, 
+    "o3-mini": {"input": 1.1, "output": 4.4}, 
+    "o4-mini": {"input": 4.00, "output": 16.0},
+    
+    # OpenAI Legacy Models
+    "text-davinci-003": {"input": 20.0, "output": 20.0},
+    "text-davinci-002": {"input": 20.0, "output": 20.0},
+    "code-davinci-002": {"input": 20.0, "output": 20.0},
+    
+    # Claude 4 Models (2025) - Verified
+    "claude-4-opus": {"input": 15.0, "output": 75.0},
+    "claude-opus-4": {"input": 15.0, "output": 75.0},
+    "claude-4-sonnet": {"input": 3.0, "output": 15.0},
+    "claude-sonnet-4": {"input": 3.0, "output": 15.0},
+    
+    # Claude 3.5 Models - Verified 2025
+    "claude-3-5-sonnet": {"input": 3.0, "output": 15.0},
+    "claude-3-5-sonnet-latest": {"input": 3.0, "output": 15.0},
+    "claude-3-5-haiku": {"input": 1.0, "output": 5.0}, 
+    "claude-3-5-haiku-latest": {"input": 1.0, "output": 5.0},
+    "claude-3-7-sonnet": {"input": 3.0, "output": 15.0},  # Same as 3.5 sonnet
+    "claude-3-7-sonnet-latest": {"input": 3.0, "output": 15.0},
+    
+    # Claude 3 Models
+    "claude-3-opus": {"input": 15.0, "output": 75.0},
+    "claude-3-opus-latest": {"input": 15.0, "output": 75.0},
+    "claude-3-sonnet": {"input": 3.0, "output": 15.0},
+    "claude-3-haiku": {"input": 0.25, "output": 1.25},
+    
+    # Claude 2 Models
+    "claude-2": {"input": 8.0, "output": 24.0},
+    "claude-2.1": {"input": 8.0, "output": 24.0},
+    "claude-2.0": {"input": 8.0, "output": 24.0},
+    
+    # Claude Instant
+    "claude-instant": {"input": 0.8, "output": 2.4},
+    "claude-instant-1": {"input": 0.8, "output": 2.4},
+    "claude-instant-1.2": {"input": 0.8, "output": 2.4},
+    
+    # Google Gemini 2.5 Series (2025) - Verified
+    "gemini-2.5-pro": {"input": 1.25, "output": 10.0},  # Up to 200k tokens
+    "gemini-2.5-pro-preview": {"input": 1.25, "output": 10.0},
+    "gemini-2.5-flash": {"input": 0.15, "output": 0.6},  # Non-thinking
+    "gemini-2.5-flash-preview": {"input": 0.15, "output": 0.6},
+    
+    # Google Gemini 2.0 Series - Verified
+    "gemini-2.0-flash": {"input": 0.1, "output": 0.4},
+    "gemini-2.0-flash-exp": {"input": 0.0, "output": 0.0},  # Free experimental
+    "gemini-2.0-flash-experimental": {"input": 0.0, "output": 0.0},
+    
+    # Google Gemini 1.5 Series - Verified
+    "gemini-1.5-pro": {"input": 1.25, "output": 5.0},  # Up to 128k tokens
+    "gemini-1.5-pro-preview": {"input": 1.25, "output": 5.0},
+    "gemini-1.5-flash": {"input": 0.075, "output": 0.3},  # Up to 128k tokens
+    "gemini-1.5-flash-8b": {"input": 0.0375, "output": 0.15},
+    
+    # Google Gemini 1.0 Series
+    "gemini-pro": {"input": 0.5, "output": 1.5},
+    "gemini-pro-vision": {"input": 0.25, "output": 0.5},
+    "gemini-1.0-pro": {"input": 0.5, "output": 1.5},
+    
+    # Google PaLM Series
+    "text-bison": {"input": 1.0, "output": 1.0},
+    "text-bison-32k": {"input": 1.0, "output": 1.0},
+    "chat-bison": {"input": 1.0, "output": 1.0},
+    "chat-bison-32k": {"input": 1.0, "output": 1.0},
+    
+    # Meta Llama 4 Series (2025)
+    "llama-4-maverick-17b": {"input": 0.2, "output": 0.6},
+    "llama-4-scout-17b": {"input": 0.11, "output": 0.34},
+    "llama-guard-4-12b": {"input": 0.20, "output": 0.20},
+    "meta-llama/llama-4-maverick-17b-128e-instruct": {"input": 0.2, "output": 0.6},
+    "meta-llama/llama-4-scout-17b-16e-instruct": {"input": 0.11, "output": 0.34},
+    "meta-llama/llama-guard-4-12b-128k": {"input": 0.20, "output": 0.20},
+    
+    # Meta Llama 3.x Series - Verified 2025 (Together AI pricing)
+    "llama-3.3-70b": {"input": 0.54, "output": 0.88}, 
+    "llama-3.1-405b": {"input": 6.0, "output": 12.0},  
+    "llama-3.1-70b": {"input": 0.54, "output": 0.88},  
+    "llama-3.1-8b": {"input": 0.10, "output": 0.18},   
+    "llama-3-70b": {"input": 0.54, "output": 0.88},    
+    "llama-3-8b": {"input": 0.10, "output": 0.18},     
+    "llama-guard-3-8b": {"input": 0.20, "output": 0.20},
+    "meta-llama/llama-3.3-70b-versatile-128k": {"input": 0.54, "output": 0.88}, 
+    "meta-llama/llama-3.1-8b-instant-128k": {"input": 0.10, "output": 0.18},     
+    "meta-llama/llama-3-70b-8k": {"input": 0.54, "output": 0.88},                
+    "meta-llama/llama-3-8b-8k": {"input": 0.10, "output": 0.18},                 
+    "meta-llama/llama-guard-3-8b-8k": {"input": 0.20, "output": 0.20},
+    
+    # Mistral Models
+    "mistral-large": {"input": 2.0, "output": 6.0},
+    "mistral-medium": {"input": 2.7, "output": 8.1},
+    "mistral-small": {"input": 0.1, "output": 0.3},
+    "mistral-tiny": {"input": 0.14, "output": 0.42},
+    "mistral-7b-instruct": {"input": 0.15, "output": 0.15},
+    "mistral-8x7b-instruct": {"input": 0.24, "output": 0.24},
+    "mistral-saba-24b": {"input": 0.79, "output": 0.79},
+    "mistral/mistral-saba-24b": {"input": 0.79, "output": 0.79},
+    
+    # Cohere Models
+    "command": {"input": 1.0, "output": 2.0},
+    "command-light": {"input": 0.3, "output": 0.6},
+    "command-nightly": {"input": 1.0, "output": 2.0},
+    "command-r": {"input": 0.5, "output": 1.5},
+    "command-r-plus": {"input": 3.0, "output": 15.0},
+    
+    # DeepSeek Models
+    "deepseek-r1-distill-llama-70b": {"input": 0.75, "output": 0.99},
+    "deepseek-ai/deepseek-r1-distill-llama-70b": {"input": 0.75, "output": 0.99},
+    "deepseek-coder": {"input": 0.14, "output": 0.28},
+    "deepseek-chat": {"input": 0.14, "output": 0.28},
+    "deepseek/deepseek-v3-0324": {"input": 0.14, "output": 0.28},
+    
+    # Qwen Models
+    "qwen-qwq-32b": {"input": 0.29, "output": 0.39},
+    "qwen/qwen-qwq-32b-preview-128k": {"input": 0.29, "output": 0.39},
+    "qwen-turbo": {"input": 0.3, "output": 0.6},
+    "qwen-plus": {"input": 0.5, "output": 2.0},
+    "qwen-max": {"input": 2.0, "output": 6.0},
+    "qwen2.5-32b-instruct": {"input": 0.7, "output": 2.8},
+    "qwen2.5-max": {"input": 1.6, "output": 6.4},
+    
+    # Google Gemma Models
+    "gemma-2-9b": {"input": 0.20, "output": 0.20},
+    "gemma-2-27b": {"input": 0.27, "output": 0.27},
+    "gemma-7b-it": {"input": 0.07, "output": 0.07},
+    "google/gemma-2-9b-8k": {"input": 0.20, "output": 0.20},
+    
+    # Together AI Models
+    "together-ai/redpajama-incite-7b-chat": {"input": 0.2, "output": 0.2},
+    "together-ai/redpajama-incite-base-3b-v1": {"input": 0.1, "output": 0.1},
+    
+    # Perplexity Models
+    "pplx-7b-chat": {"input": 0.07, "output": 0.28},
+    "pplx-70b-chat": {"input": 0.7, "output": 2.8},
+    "pplx-7b-online": {"input": 0.07, "output": 0.28},
+    "pplx-70b-online": {"input": 0.7, "output": 2.8},
+
+    # Grok Models
+    "grok-3-latest": {"input": 3, "output": 15},
+    "grok-3": {"input": 3, "output": 15},
+    "grok-3-fast": {"input": 5, "output": 25},
+    "grok-3-mini": {"input": 0.3, "output": 0.5},
+    "grok-3-mini-fast": {"input": 0.6, "output": 4},
+
+}
+
+# Provider average pricing fallbacks
+PROVIDER_AVERAGES = {
+    "anthropic": {"input": 3.0, "output": 15.0},    # Average of Claude 3.5 Sonnet
+    "openai": {"input": 2.5, "output": 10.0},       # GPT-4o pricing
+    "google": {"input": 0.5, "output": 1.5},        # Gemini Pro average
+    "meta": {"input": 0.3, "output": 0.5},          # Llama average
+    "mistral": {"input": 0.5, "output": 1.5},       # Mistral average
+    "cohere": {"input": 1.0, "output": 2.0},        # Command model average
+    "deepseek": {"input": 0.3, "output": 0.5},      # DeepSeek average
+    "qwen": {"input": 0.5, "output": 1.0},          # Qwen average
+    "together": {"input": 0.15, "output": 0.15},    # Together AI average
+    "perplexity": {"input": 0.4, "output": 1.5},    # Perplexity average
+    "grok": {"input": 2.4, "output": 12},           # Grok average
+    "groq": {"input": 0.3, "output": 0.6},          # Groq average (placeholder)
+}
+
+def get_provider_from_model(model: str) -> str:
+    """Extract provider name from model string"""
+    model_lower = model.lower()
+    
+    if any(claude in model_lower for claude in ["claude", "anthropic"]):
+        return "anthropic"
+    elif any(gpt in model_lower for gpt in ["gpt", "openai", "o1", "o3", "o4", "text-davinci", "code-davinci"]):
+        return "openai"  
+    elif any(gemini in model_lower for gemini in ["gemini", "google", "gemma", "palm", "bison"]):
+        return "google"
+    elif any(llama in model_lower for llama in ["llama", "meta"]):
+        return "meta"
+    elif "mistral" in model_lower:
+        return "mistral"
+    elif any(cohere in model_lower for cohere in ["command", "cohere"]):
+        return "cohere"
+    elif "deepseek" in model_lower:
+        return "deepseek"
+    elif any(qwen in model_lower for qwen in ["qwen", "qwq"]):
+        return "qwen"
+    elif any(together in model_lower for together in ["together", "redpajama"]):
+        return "together"
+    elif any(pplx in model_lower for pplx in ["pplx", "perplexity"]):
+        return "perplexity"
+    elif any(grok in model_lower for grok in ["grok", "xAI"]):
+        return "grok"
+    elif "groq" in model_lower:
+        return "groq"
+    else:
+        return "unknown"
+
+def normalize_model_name(model: str) -> str:
+    """Normalize model name by stripping dates and provider prefixes"""
+    import re
+    
+    model_lower = model.lower()
+    # Remove provider prefixes (generalizable pattern: any_provider/)
+    model_lower = re.sub(r'^[^/]+/', '', model_lower)
+    # Strip Google/Vertex prefixes
+    model_lower = model_lower.replace('publishers/google/models/', '').replace('models/', '')
+    
+    # Strip date suffixes (20240229, 20241022, etc.) but preserve model versions like o1-mini, o3-mini
+    # Pattern: remove -YYYYMMDD or -YYYY-MM-DD at the end
+    date_pattern = r'-\d{8}$|_\d{8}$|-\d{4}-\d{2}-\d{2}$'
+    model_lower = re.sub(date_pattern, '', model_lower)
+    
+    return model_lower
+
+def calculate_cost(model: str, token_usage: dict) -> float:
+    model_lower = normalize_model_name(model)
+    
+    # Try exact match first, then longest prefix match
+    pricing = (
+        MODEL_PRICING.get(model_lower) or
+        MODEL_PRICING.get(
+            next((prefix for prefix in sorted(MODEL_PRICING.keys(), key=len, reverse=True) 
+                  if model_lower.startswith(prefix)), None)
+        ) or
+        PROVIDER_AVERAGES.get(
+            get_provider_from_model(model), 
+            {"input": 2.5, "output": 10.0}
+        )
+    )
+    
+    # Print warning only if using fallback pricing
+    if model_lower not in MODEL_PRICING:
+        provider = get_provider_from_model(model)
+        if provider in PROVIDER_AVERAGES:
+            logger.warning(f"No pricing found for model: {model}, using {provider} average pricing")
+        else:
+            logger.warning(f"No pricing found for model: {model}, using default pricing")
+    
+    input_tokens = token_usage.get("prompt_tokens", token_usage.get("input_tokens", 0))
+    output_tokens = token_usage.get("completion_tokens", token_usage.get("output_tokens", 0))
+    
+    cost = ((input_tokens * pricing["input"]) + (output_tokens * pricing["output"])) / 1_000_000
+    return cost

lucidicai/utils/__init__.py

@@ -0,0 +1 @@
+"""Utility modules."""