lucidicai 2.1.2__py3-none-any.whl → 3.0.0__py3-none-any.whl

lucidicai/telemetry/extract.py

@@ -1,6 +1,7 @@
 """Extraction utilities matching TypeScript SDK for span attribute processing."""
 import json
 from typing import List, Dict, Any, Optional
+from ..utils.logger import debug, info, warning, error, verbose, truncate_id
 
 
 def detect_is_llm_span(span) -> bool:
@@ -20,65 +21,6 @@ def detect_is_llm_span(span) -> bool:
     return False
 
 
-def extract_images(attrs: Dict[str, Any]) -> List[str]:
-    """Extract images from span attributes - matches TypeScript logic.
-    
-    Looks for images in:
-    - gen_ai.prompt.{i}.content arrays with image_url items
-    - Direct image attributes
-    """
-    images = []
-    
-    # Check indexed prompt content for images (gen_ai.prompt.{i}.content)
-    for i in range(50):
-        key = f"gen_ai.prompt.{i}.content"
-        if key in attrs:
-            content = attrs[key]
-            
-            # Parse if JSON string
-            if isinstance(content, str):
-                try:
-                    content = json.loads(content)
-                except:
-                    continue
-            
-            # Extract images from content array
-            if isinstance(content, list):
-                for item in content:
-                    if isinstance(item, dict):
-                        if item.get("type") == "image_url":
-                            image_url = item.get("image_url", {})
-                            if isinstance(image_url, dict):
-                                url = image_url.get("url", "")
-                                if url.startswith("data:image"):
-                                    images.append(url)
-                        elif item.get("type") == "image":
-                            # Anthropic format
-                            source = item.get("source", {})
-                            if isinstance(source, dict):
-                                data = source.get("data", "")
-                                media_type = source.get("media_type", "image/jpeg")
-                                if data:
-                                    images.append(f"data:{media_type};base64,{data}")
-    
-    # Also check direct gen_ai.prompt list
-    prompt_list = attrs.get("gen_ai.prompt")
-    if isinstance(prompt_list, list):
-        for msg in prompt_list:
-            if isinstance(msg, dict):
-                content = msg.get("content")
-                if isinstance(content, list):
-                    for item in content:
-                        if isinstance(item, dict) and item.get("type") == "image_url":
-                            image_url = item.get("image_url", {})
-                            if isinstance(image_url, dict):
-                                url = image_url.get("url", "")
-                                if url.startswith("data:image"):
-                                    images.append(url)
-    
-    return images
-
-
 def extract_prompts(attrs: Dict[str, Any]) -> Optional[List[Dict]]:
     """Extract prompts as message list from span attributes.
     
@@ -102,7 +44,7 @@ def extract_prompts(attrs: Dict[str, Any]) -> Optional[List[Dict]]:
             try:
                 parsed = json.loads(content)
                 content = parsed
-            except:
+            except (ValueError, TypeError):
                 pass
         
         # Format content
@@ -114,6 +56,29 @@ def extract_prompts(attrs: Dict[str, Any]) -> Optional[List[Dict]]:
                     text_parts.append(item.get("text", ""))
             if text_parts:
                 content = " ".join(text_parts)
+
+        # if we have no content here then that means we have a tool call
+        # NOTE: for now, I am assumign that tools call history only shows up if there is no content
+        # based on my testing of otel spans in different cases. Should be revisited if this is not the case.
+        if not content:
+            # look for tool calls in the attributes
+            j = 0
+            tool_calls = []
+            while True:
+                tool_key_name = f"gen_ai.prompt.{i}.tool_calls.{j}.name"
+                tool_key_arguments = f"gen_ai.prompt.{i}.tool_calls.{j}.arguments"
+                if tool_key_name not in attrs:
+                    break
+                name = attrs[tool_key_name]
+                arguments = attrs[tool_key_arguments]
+                tool_calls.append({"name": name, "arguments": arguments})
+                j += 1
+
+            # for now, just make content as "Tool Calls:\n 1) <tool call 1> \n 2) <tool call 2> \n ..."
+            if tool_calls:
+                content = 'Tool Calls:' if len(tool_calls) > 1 else 'Tool Call:'
+                for k, tool_call in enumerate(tool_calls):
+                    content += f'\n{k + 1}) {json.dumps(tool_call, indent=4)}'
         
         messages.append({"role": role, "content": content})
     
@@ -132,7 +97,7 @@ def extract_prompts(attrs: Dict[str, Any]) -> Optional[List[Dict]]:
             parsed = json.loads(ai_prompt)
             if isinstance(parsed, list):
                 return parsed
-        except:
+        except (ValueError, TypeError):
             pass
     
     return None
@@ -143,7 +108,8 @@ def extract_completions(span, attrs: Dict[str, Any]) -> Optional[str]:
     completions = []
     
     # Check indexed format (gen_ai.completion.{i}.content)
-    for i in range(50):
+    i = 0
+    while True:
         key = f"gen_ai.completion.{i}.content"
         if key not in attrs:
             break
@@ -153,8 +119,9 @@ def extract_completions(span, attrs: Dict[str, Any]) -> Optional[str]:
         else:
             try:
                 completions.append(json.dumps(content))
-            except:
+            except (ValueError, TypeError):
                 completions.append(str(content))
+        i += 1
     
     if completions:
         return "\n".join(completions)
@@ -180,6 +147,36 @@ def extract_completions(span, attrs: Dict[str, Any]) -> Optional[str]:
     return None
 
 
+def extract_tool_calls(span, attrs: Dict[str, Any]) -> Optional[List[Dict]]:
+    """Extract tool calls from span attributes."""
+
+    debug(f"[Telemetry] Extracting tool calls from span")
+
+    # check if this is a tool call span
+    if not attrs.get("gen_ai.completion.0.finish_reason") == "tool_calls":
+        debug(f"[Telemetry] Not a tool call span {span.name}")
+        return None
+
+    tool_calls = []
+    i = 0
+    while True:
+        key_name = f"gen_ai.completion.0.tool_calls.{i}.name"
+        key_arguments = f"gen_ai.completion.0.tool_calls.{i}.arguments"
+        if key_name not in attrs:
+            break
+        name = attrs[key_name]
+        arguments = attrs[key_arguments]
+        debug(f"[Telemetry] Extracted tool call {name} with arguments: {arguments}")
+        tool_calls.append({"name": name, "arguments": arguments})
+        i += 1
+
+    if tool_calls:
+        # prettify the tool calls and return as a string
+        tool_calls_str = [json.dumps(tool_call, indent=4) for tool_call in tool_calls]
+        return "\n".join(tool_calls_str)
+
+    return None
+
 def extract_model(attrs: Dict[str, Any]) -> Optional[str]:
     """Extract model name from span attributes."""
     return (

lucidicai/telemetry/litellm_bridge.py

@@ -18,6 +18,7 @@ from lucidicai.sdk.event import create_event
 from lucidicai.sdk.init import get_session_id
 from lucidicai.telemetry.utils.model_pricing import calculate_cost
 from lucidicai.sdk.context import current_parent_event_id
+from lucidicai.telemetry.utils.provider import detect_provider
 
 logger = logging.getLogger("Lucidic")
 DEBUG = os.getenv("LUCIDIC_DEBUG", "False") == "True"
@@ -117,7 +118,7 @@ class LucidicLiteLLMCallback(CustomLogger):
             
             # Extract model and provider info
             model = kwargs.get("model", pre_call_info.get("model", "unknown"))
-            provider = self._extract_provider(model)
+            provider = detect_provider(model=model)
             
             # Get messages for description
             messages = kwargs.get("messages", pre_call_info.get("messages", []))
@@ -132,9 +133,6 @@ class LucidicLiteLLMCallback(CustomLogger):
             if usage:
                 cost = self._calculate_litellm_cost(model, usage)
             
-            # Extract any images from multimodal requests
-            images = self._extract_images_from_messages(messages)
-            
             # Get parent event ID from context
             parent_id = None
             try:
@@ -191,7 +189,7 @@ class LucidicLiteLLMCallback(CustomLogger):
             
             # Extract model info
             model = kwargs.get("model", pre_call_info.get("model", "unknown"))
-            provider = self._extract_provider(model)
+            provider = detect_provider(model=model)
             
             # Get messages for description
             messages = kwargs.get("messages", pre_call_info.get("messages", []))
@@ -251,26 +249,6 @@ class LucidicLiteLLMCallback(CustomLogger):
         """Async version of log_stream_event"""
         self.log_stream_event(kwargs, response_obj, start_time, end_time)
     
-    def _extract_provider(self, model: str) -> str:
-        """Extract provider from model string"""
-        if "/" in model:
-            return model.split("/")[0]
-        
-        # Try to infer provider from model name patterns
-        model_lower = model.lower()
-        if "gpt" in model_lower:
-            return "openai"
-        elif "claude" in model_lower:
-            return "anthropic"
-        elif "gemini" in model_lower:
-            return "vertex_ai"
-        elif "llama" in model_lower:
-            return "meta"
-        elif "mistral" in model_lower:
-            return "mistral"
-        
-        return "unknown"
-    
     def _format_messages(self, messages: List[Dict[str, Any]]) -> str:
         """Format messages into a description string"""
         if not messages:
@@ -347,25 +325,6 @@ class LucidicLiteLLMCallback(CustomLogger):
             logger.debug(f"Could not calculate cost for {model}: {e}")
             return None
     
-    def _extract_images_from_messages(self, messages: List[Dict[str, Any]]) -> List[str]:
-        """Extract base64 images from multimodal messages"""
-        images = []
-        
-        for msg in messages:
-            if isinstance(msg, dict):
-                content = msg.get("content", "")
-                if isinstance(content, list):
-                    for item in content:
-                        if isinstance(item, dict) and item.get("type") == "image_url":
-                            image_url = item.get("image_url", {})
-                            if isinstance(image_url, dict):
-                                url = image_url.get("url", "")
-                                if url.startswith("data:image"):
-                                    images.append(url)
-                                    
-        return images
-
-
 def setup_litellm_callback():
     """Registers the LucidicLiteLLMCallback with LiteLLM if available.
     

lucidicai/telemetry/lucidic_exporter.py

@@ -1,26 +1,60 @@
 """Custom OpenTelemetry exporter for Lucidic (Exporter-only mode).
 
-Converts completed spans into immutable typed LLM events via Client.create_event(),
-which enqueues non-blocking delivery through the EventQueue.
+Converts completed spans into immutable typed LLM events via emit_event(),
+which fires events in the background without blocking the exporter.
 """
-import json
-from typing import Sequence, Optional, Dict, Any, List
+from typing import Sequence, Optional, Dict, Any, List, TYPE_CHECKING
 from datetime import datetime, timezone
 from opentelemetry.sdk.trace import ReadableSpan
 from opentelemetry.sdk.trace.export import SpanExporter, SpanExportResult
-from opentelemetry.trace import StatusCode
 from opentelemetry.semconv_ai import SpanAttributes
+import threading
 
-from ..sdk.event import create_event
+from ..sdk.event import emit_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
+from .extract import detect_is_llm_span, extract_prompts, extract_completions, extract_model, extract_tool_calls
+from .utils.provider import detect_provider
 from ..utils.logger import debug, info, warning, error, verbose, truncate_id
 
+if TYPE_CHECKING:
+    from ..client import LucidicAI
+
 
 class LucidicSpanExporter(SpanExporter):
-    """Exporter that creates immutable LLM events for completed spans."""
+    """Exporter that creates immutable LLM events for completed spans.
+
+    Uses emit_event() for fire-and-forget event creation without blocking.
+    Supports multi-client routing via client registry.
+    """
+
+    def __init__(self):
+        """Initialize the exporter."""
+        self._shutdown = False
+        # Client registry for multi-client support
+        self._client_registry: Dict[str, "LucidicAI"] = {}
+        self._registry_lock = threading.Lock()
+
+    def register_client(self, client: "LucidicAI") -> None:
+        """Register a client for span routing.
+
+        Args:
+            client: The LucidicAI client to register
+        """
+        with self._registry_lock:
+            self._client_registry[client._client_id] = client
+            debug(f"[Exporter] Registered client {client._client_id[:8]}...")
+
+    def unregister_client(self, client_id: str) -> None:
+        """Unregister a client.
+
+        Args:
+            client_id: The client ID to unregister
+        """
+        with self._registry_lock:
+            self._client_registry.pop(client_id, None)
+            debug(f"[Exporter] Unregistered client {client_id[:8]}...")
 
     def export(self, spans: Sequence[ReadableSpan]) -> SpanExportResult:
         try:
@@ -43,6 +77,8 @@ class LucidicSpanExporter(SpanExporter):
                 return
 
             debug(f"[Telemetry] Processing LLM span: {span.name}")
+            verbose(f"[Telemetry] Span: {span.attributes}")
+            verbose(f"[Telemetry] Span name: {span.name}")
 
             attributes = dict(span.attributes or {})
 
@@ -66,7 +102,8 @@ class LucidicSpanExporter(SpanExporter):
             if not target_session_id:
                 try:
                     target_session_id = current_session_id.get(None)
-                except Exception:
+                except Exception as e:
+                    debug(f"[Telemetry] Failed to get session_id from contextvar: {e}")
                     target_session_id = None
             if not target_session_id:
                 target_session_id = get_session_id()
@@ -83,7 +120,8 @@ class LucidicSpanExporter(SpanExporter):
                     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:
+                except Exception as e:
+                    debug(f"[Telemetry] Failed to get parent_event_id from contextvar: {e}")
                     parent_id = None
             
             if not parent_id:
@@ -96,159 +134,127 @@ class LucidicSpanExporter(SpanExporter):
 
             # Typed fields using extract utilities
             model = extract_model(attributes) or 'unknown'
-            provider = self._detect_provider_name(attributes)
+            provider = detect_provider(model=model, attributes=attributes)
             messages = extract_prompts(attributes) or []
             params = self._extract_params(attributes)
             output_text = extract_completions(span, attributes)
+            tool_calls = extract_tool_calls(span, attributes)
+            debug(f"[Telemetry] Extracted tool calls: {tool_calls}")
 
             # Debug for responses.create
             if span.name == "openai.responses.create":
                 debug(f"[Telemetry] Extracted messages: {messages}")
                 debug(f"[Telemetry] Extracted output: {output_text}")
+                debug(f"[Telemetry] Extracted tool calls: {tool_calls}")
+
+
+            # see if tool calls need to be used instead of output_text
+            if not output_text or output_text == "Response received" or not tool_calls:
+
+                if tool_calls:
+                    debug(f"[Telemetry] Using tool calls for span {span.name}")
+                    output_text = tool_calls
 
-            # Skip spans with no meaningful output (likely incomplete or duplicate instrumentation)
-            if not output_text or output_text == "Response received":
                 # Only use "Response received" if we have other meaningful data
-                if not messages and not attributes.get("lucidic.instrumented"):
+                if not messages and not tool_calls and not attributes.get("lucidic.instrumented"):
                     verbose(f"[Telemetry] Skipping span {span.name} with no meaningful content")
                     return
                 # Use a more descriptive default if we must
                 if not output_text:
+                    debug(f"[Telemetry] No output text for span {span.name}. Using default 'Response received'")
                     output_text = "Response received"
 
             input_tokens = self._extract_prompt_tokens(attributes)
             output_tokens = self._extract_completion_tokens(attributes)
             cost = self._calculate_cost(attributes)
-            images = extract_images(attributes)
 
+            # Prepare event data for async creation
+            event_data = {
+                'type': 'llm_generation',
+                'session_id': target_session_id,
+                'occurred_at': occurred_at,
+                'duration': duration_seconds,
+                'provider': provider,
+                'model': model,
+                'messages': messages,
+                'params': params,
+                'output': output_text,
+                'input_tokens': input_tokens,
+                'output_tokens': output_tokens,
+                'cost': cost,
+                'raw': None,
+                'parent_event_id': parent_id,
+            }
+            
+            # Get client_id for routing
+            client_id = attributes.get("lucidic.client_id")
+
+            if not self._shutdown:
+                self._send_event_async(event_data, span.name, parent_id, client_id)
+
+            debug(
+                f"[Telemetry] Queued LLM event creation for span {span.name} "
+                f"(session: {truncate_id(target_session_id)}, client: {truncate_id(client_id)})"
+            )
+
+        except Exception as e:
+            error(f"[Telemetry] Failed to process span {span.name}: {e}")
+    
+    def _send_event_async(
+        self,
+        event_data: Dict[str, Any],
+        span_name: str,
+        parent_id: Optional[str],
+        client_id: Optional[str] = None,
+    ) -> None:
+        """Send event asynchronously in a background thread.
+
+        Args:
+            event_data: Event data to send
+            span_name: Name of the span (for logging)
+            parent_id: Parent event ID (for context)
+            client_id: Client ID for routing (if available)
+        """
+        try:
             # 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)}, session_id: {truncate_id(target_session_id)}")
-                event_id = create_event(
-                type="llm_generation",
-                session_id=target_session_id,  # Pass the session_id explicitly
-                occurred_at=occurred_at,
-                duration=duration_seconds,
-                provider=provider,
-                model=model,
-                messages=messages,
-                params=params,
-                output=output_text,
-                input_tokens=input_tokens,
-                output_tokens=output_tokens,
-                cost=cost,
-                raw={"images": images} if images else None,
-                parent_event_id=parent_id,  # Pass the parent_id explicitly
-            )
+                # Try to route to specific client if client_id is available
+                if client_id:
+                    with self._registry_lock:
+                        client = self._client_registry.get(client_id)
+                    if client:
+                        # Use client's event resource directly
+                        try:
+                            response = client._resources["events"].create(**event_data)
+                            event_id = response if response else None
+                            debug(
+                                f"[Telemetry] Routed LLM event {truncate_id(event_id)} to client {client_id[:8]}..."
+                            )
+                            return
+                        except Exception as e:
+                            debug(f"[Telemetry] Failed to route event to client: {e}")
+                            # Fall through to emit_event
+
+                # Fallback to emit_event (uses global state)
+                event_id = emit_event(**event_data)
+                debug(
+                    f"[Telemetry] Emitted LLM event {truncate_id(event_id)} from span {span_name}"
+                )
             finally:
                 # Reset parent context
                 if token:
                     parent_context.reset(token)
-            
-            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:
-            error(f"[Telemetry] Failed to process span {span.name}: {e}")
-    
-    
-    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
-            description = self._extract_description(span, attributes)
-            
-            # Extract images if present
-            images = self._extract_images(attributes)
-            
-            # Get model info
-            model = attributes.get(SpanAttributes.LLM_RESPONSE_MODEL) or \
-                   attributes.get(SpanAttributes.LLM_REQUEST_MODEL) or \
-                   attributes.get('gen_ai.request.model') or 'unknown'
-            
-            # Resolve target session id for this span
-            target_session_id = attributes.get('lucidic.session_id')
-            if not target_session_id:
-                try:
-                    target_session_id = current_session_id.get(None)
-                except Exception:
-                    target_session_id = None
-            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 None
-
-            # Create event
-            event_kwargs = {
-                'session_id': target_session_id,  # Pass session_id explicitly
-                'description': description,
-                'result': "Processing...",  # Will be updated when span ends
-                'model': model
-            }
+            error(f"[Telemetry] Failed to send event for span {span_name}: {e}")
 
-            if images:
-                event_kwargs['screenshots'] = images
-
-            return create_event(**event_kwargs)
-            
-        except Exception as 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) -> None:
-        """Deprecated: events are immutable; no updates performed."""
-        return
-    
-    def _extract_description(self, span: ReadableSpan, attributes: Dict[str, Any]) -> str:
-        """Extract description from span attributes"""
-        # Try to get prompts/messages
-        prompts = attributes.get(SpanAttributes.LLM_PROMPTS) or \
-                 attributes.get('gen_ai.prompt')
-        
-        verbose(f"[Telemetry] Extracting description from attributes: {attributes}, prompts: {prompts}")
-
-        if prompts:
-            if isinstance(prompts, list) and prompts:
-                # Handle message list format
-                return self._format_messages(prompts)
-            elif isinstance(prompts, str):
-                return prompts
-                
-        # Fallback to span name
-        return f"LLM Call: {span.name}"
-    
-    def _extract_result(self, span: ReadableSpan, attributes: Dict[str, Any]) -> str:
-        """Extract result/response from span attributes"""
-        # Try to get completions
-        completions = attributes.get(SpanAttributes.LLM_COMPLETIONS) or \
-                     attributes.get('gen_ai.completion')
-        
-        if completions:
-            if isinstance(completions, list) and completions:
-                # Handle multiple completions
-                return "\n".join(str(c) for c in completions)
-            elif isinstance(completions, str):
-                return completions
-                
-        # Check for error
-        if span.status.status_code == StatusCode.ERROR:
-            return f"Error: {span.status.description or 'Unknown error'}"
-            
-        return "Response received"
-    
-    def _detect_provider_name(self, attributes: Dict[str, Any]) -> str:
-        name = attributes.get('gen_ai.system') or attributes.get('service.name')
-        if name:
-            return str(name)
-        return "openai" if 'openai' in (str(attributes.get('service.name', '')).lower()) else "unknown"
-    
 
     def _extract_params(self, attributes: Dict[str, Any]) -> Dict[str, Any]:
         return {
@@ -300,7 +306,13 @@ class LucidicSpanExporter(SpanExporter):
         return None
     
     def shutdown(self) -> None:
-        return None
+        """Shutdown the exporter and flush pending events."""
+        from ..sdk.event import flush
+        self._shutdown = True
+        # Flush any pending background events
+        flush(timeout=5.0)
+        debug("[Telemetry] LucidicSpanExporter shutdown complete")
 
     def force_flush(self, timeout_millis: int = 30000) -> bool:
-        return True
+        """Force flush is a no-op since events are sent immediately in background threads."""
+        return True

lucidicai/telemetry/openai_agents_instrumentor.py

@@ -104,8 +104,8 @@ class OpenAIAgentsInstrumentor:
                 import openai
                 openai.chat.completions.create = self._original_openai_create
                 logger.debug("Restored OpenAI chat.completions.create")
-            except:
-                pass
+            except Exception as e:
+                logger.debug(f"[OpenAIAgents] Failed to restore OpenAI client: {e}")
 
 
 class OpenAIAgentsTracingProcessor: