llmops-observability 10.0.4__tar.gz → 10.0.5__tar.gz

{llmops_observability-10.0.4 → llmops_observability-10.0.5}/PKG-INFO

@@ -1,12 +1,13 @@
 Metadata-Version: 2.4
 Name: llmops-observability
-Version: 10.0.4
-Summary: LLMOps Observability SDK with direct Langfuse integration (no SQS/batching)
+Version: 10.0.5
+Summary: LLMOps Observability SDK with direct Langfuse integration and SQS event streaming
 Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 Requires-Dist: langfuse>=2.0.0
 Requires-Dist: httpx
 Requires-Dist: python-dotenv
+Requires-Dist: boto3
 
 # LLMOps Observability SDK
 
@@ -15,7 +16,7 @@ A lightweight Python SDK for LLM observability with **direct Langfuse integratio
 ## Key Features
 
 - ⚡ **Instant Tracing**: Sends traces directly to Langfuse in real-time
-- 🎯 **Simple API**: Same decorators as veriskGO (`@track_function`, `@track_llm_call`)
+- 🎯 **Simple API**: (`@track_function`, `@track_llm_call`)
 - 🚫 **No Complexity**: No SQS queues, no batching, no background workers
 - 🔄 **Sync & Async**: Supports both synchronous and asynchronous functions
 - 🎨 **Provider Agnostic**: Works with any LLM provider (Bedrock, OpenAI, Anthropic, etc.)
@@ -134,7 +135,7 @@ TraceManager.start_trace(
 TraceManager.end_trace()
 ```
 
-**Method 3: Using `finalize_and_send()` (veriskGO-compatible)**
+**Method 3: Using `finalize_and_send()` (llmops-observability)**
 ```python
 # Start trace
 TraceManager.start_trace(name="chat_session")

{llmops_observability-10.0.4 → llmops_observability-10.0.5}/README.md

@@ -5,7 +5,7 @@ A lightweight Python SDK for LLM observability with **direct Langfuse integratio
 ## Key Features
 
 - ⚡ **Instant Tracing**: Sends traces directly to Langfuse in real-time
-- 🎯 **Simple API**: Same decorators as veriskGO (`@track_function`, `@track_llm_call`)
+- 🎯 **Simple API**: (`@track_function`, `@track_llm_call`)
 - 🚫 **No Complexity**: No SQS queues, no batching, no background workers
 - 🔄 **Sync & Async**: Supports both synchronous and asynchronous functions
 - 🎨 **Provider Agnostic**: Works with any LLM provider (Bedrock, OpenAI, Anthropic, etc.)
@@ -124,7 +124,7 @@ TraceManager.start_trace(
 TraceManager.end_trace()
 ```
 
-**Method 3: Using `finalize_and_send()` (veriskGO-compatible)**
+**Method 3: Using `finalize_and_send()` (llmops-observability)**
 ```python
 # Start trace
 TraceManager.start_trace(name="chat_session")

{llmops_observability-10.0.4 → llmops_observability-10.0.5}/pyproject.toml

@@ -1,13 +1,14 @@
 [project]
 name = "llmops-observability"
-version = "10.0.4"
-description = "LLMOps Observability SDK with direct Langfuse integration (no SQS/batching)"
+version = "10.0.5"
+description = "LLMOps Observability SDK with direct Langfuse integration and SQS event streaming"
 readme = "README.md"
 requires-python = ">=3.9"
 dependencies = [
     "langfuse>=2.0.0",
     "httpx",
     "python-dotenv",
+    "boto3",
 ]
 
 [build-system]

{llmops_observability-10.0.4 → llmops_observability-10.0.5}/src/llmops_observability/__init__.py

@@ -1,7 +1,7 @@
 """
 LLMOps Observability SDK – Public API
 Direct Langfuse integration for LLM tracing without SQS/batching.
-Enhanced with veriskGO-style features: locals capture, nested spans, instant sending.
+Enhanced with llmops-observability features: locals capture, nested spans, instant sending.
 """
 from importlib.metadata import version, PackageNotFoundError
 

{llmops_observability-10.0.4 → llmops_observability-10.0.5}/src/llmops_observability/asgi_middleware.py

@@ -1,7 +1,7 @@
 """
 ASGI Middleware for LLMOps Observability
 Automatic tracing for FastAPI and other ASGI applications
-Based on veriskGO's asgi_middleware with direct Langfuse integration
+Direct Langfuse integration for ASGI applications
 """
 import uuid
 import time

{llmops_observability-10.0.4 → llmops_observability-10.0.5}/src/llmops_observability/config.py

@@ -1,10 +1,10 @@
 """
 Configuration management for LLMOps Observability
-Direct Langfuse client configuration
+Direct Langfuse client configuration + SQS event streaming
 """
 import os
 import logging
-from typing import Optional
+from typing import Optional, Dict, Any
 from langfuse import Langfuse
 import httpx
 from dotenv import load_dotenv
@@ -113,3 +113,27 @@ def configure(
     )
     
     print(f"[LLMOps-Observability] Langfuse client configured: {base_url}")
+
+
+# ============================================================
+# SQS Configuration
+# ============================================================
+
+def get_sqs_config() -> Dict[str, Any]:
+    """
+    Get SQS configuration from environment variables.
+    
+    Environment variables:
+        - AWS_SQS_URL: SQS queue URL (required to enable SQS)
+        - AWS_PROFILE: AWS profile name (default: "default")
+        - AWS_REGION: AWS region (default: "us-east-1")
+    
+    Returns:
+        Dict with SQS configuration
+    """
+    return {
+        "aws_sqs_url": os.getenv("AWS_SQS_URL"),
+        "aws_profile": os.getenv("AWS_PROFILE", "default"),
+        "aws_region": os.getenv("AWS_REGION", "us-east-1"),
+    }
+

{llmops_observability-10.0.4 → llmops_observability-10.0.5}/src/llmops_observability/llm.py

@@ -1,7 +1,7 @@
 """
 LLM tracking decorator for LLMOps Observability
 Direct Langfuse integration for tracking LLM calls
-Enhanced with veriskGO-style input/output handling
+Enhanced with robust input/output handling and SQS event streaming
 """
 from __future__ import annotations
 import functools
@@ -11,6 +11,7 @@ import time
 import traceback
 from typing import Optional, Dict, Any, List, Union
 from .trace_manager import TraceManager
+from .sqs import send_to_sqs, is_sqs_enabled
 
 
 def extract_text(resp: Any) -> str:
@@ -569,6 +570,28 @@ def track_llm_call(
                         # Use Langfuse's update_current_generation() instead of obs.update()
                         langfuse = get_langfuse_client()
                         langfuse.update_current_generation(**update_params)
+                        
+                        # Send span event to SQS (non-blocking, independent of Langfuse)
+                        if is_sqs_enabled() and TraceManager.has_active_trace():
+                            trace_id = TraceManager._active.get("trace_id")
+                            if trace_id:
+                                span_event = {
+                                    "event_type": "span",
+                                    "trace_id": trace_id,
+                                    "span_id": obs.id if hasattr(obs, 'id') else "unknown",
+                                    "parent_span_id": None,
+                                    "name": span_name,
+                                    "timestamp": TraceManager._now(),
+                                    "duration_ms": duration_ms,
+                                    "input": input_data,
+                                    "output": output_data,
+                                    "metadata": update_params.get("metadata", {})
+                                }
+                                if usage_info:
+                                    span_event["usage"] = usage_info
+                                if "cost_details" in update_params:
+                                    span_event["cost"] = update_params["cost_details"]
+                                send_to_sqs(span_event)
                 
                 # Flush after exiting context
                 from .config import get_langfuse_client

{llmops_observability-10.0.4 → llmops_observability-10.0.5}/src/llmops_observability/pricing.py

@@ -17,6 +17,15 @@ BEDROCK_PRICING = {
         "input": 0.003,
         "output": 0.015,
     },
+    # Claude 4 Sonnet (Cross-region inference)
+    "us.anthropic.claude-sonnet-4-20250514-v1:0": {
+        "input": 0.003,  # $3 per 1M tokens
+        "output": 0.015,  # $15 per 1M tokens
+    },
+    "us.anthropic.claude-sonnet-4-5-20250929-v1:0": {
+        "input": 0.003,  # $3 per 1M tokens
+        "output": 0.015,  # $15 per 1M tokens
+    },
     # Claude 3 Sonnet
     "anthropic.claude-3-sonnet-20240229-v1:0": {
         "input": 0.003,  # $3 per 1M tokens

llmops_observability-10.0.5/src/llmops_observability/sqs.py

@@ -0,0 +1,395 @@
+# src/llmops_observability/sqs.py
+"""
+Production-grade SQS sender with batching, spillover, and clean shutdown.
+Ported from veriskGO with enhanced error handling and resilience.
+"""
+
+import json
+import boto3
+import queue
+import threading
+import time
+import os
+import atexit
+import tempfile
+import logging
+from typing import Optional, Dict, Any
+
+from .config import get_sqs_config
+
+logger = logging.getLogger(__name__)
+if not logger.handlers:
+    handler = logging.StreamHandler()
+    formatter = logging.Formatter('[llmops_observability] %(levelname)s: %(message)s')
+    handler.setFormatter(formatter)
+    logger.addHandler(handler)
+    logger.setLevel(logging.INFO)
+
+SPILLOVER_FILE = os.path.join(tempfile.gettempdir(), "llmops_observability_spillover_queue.jsonl")
+MAIN_PID = os.getpid()
+
+
+class _LLMOpsObservabilitySQS:
+    """
+    PRODUCTION-GRADE SQS SENDER
+    - Daemon worker threads (never block shutdown)
+    - Force-flush on exit (guarantees delivery)
+    - Clean shutdown (prevents Event loop is closed errors on Windows)
+    - Auto spillover for failed sends
+    - Resilient to SQS outages
+    """
+
+    SHUTDOWN_SENTINEL = None  # Used to tell workers to stop
+
+    def __init__(self):
+        self.client: Optional[Any] = None
+        self.queue_url: Optional[str] = None
+        self.sqs_enabled = False
+        self._init_once = False
+
+        # Internal queue for batching
+        self._q: queue.Queue = queue.Queue(maxsize=0)
+
+        # Flag to stop workers cleanly
+        self._shutting_down = False
+
+        # Restore spillover messages from disk
+        self._load_spillover()
+
+        # Start worker threads
+        self.worker_count = 4
+        self.workers = []
+        for i in range(self.worker_count):
+            t = threading.Thread(target=self._safe_worker_loop, daemon=True)
+            t.start()
+            self.workers.append(t)
+
+        # Initialize AWS SQS connection
+        self._auto_initialize()
+
+    # -------------------------------------------------------
+    # CLEAN SHUTDOWN SUPPORT
+    # -------------------------------------------------------
+    def shutdown(self):
+        """Safely stop worker threads without touching asyncio loop."""
+        if self._shutting_down:
+            return
+        self._shutting_down = True
+
+        # Signal workers to exit
+        for _ in range(self.worker_count):
+            self._q.put(self.SHUTDOWN_SENTINEL)
+
+        # Wait for them to finish
+        for t in self.workers:
+            try:
+                t.join(timeout=1.0)
+            except Exception:
+                pass
+
+    # -------------------------------------------------------
+    # SPILLOVER SAVE (Fallback storage)
+    # -------------------------------------------------------
+    def _spillover_save(self, message: Dict[str, Any]):
+        """Save message to disk if SQS send fails (for recovery)."""
+        try:
+            with open(SPILLOVER_FILE, "a") as f:
+                f.write(json.dumps(message) + "\n")
+            logger.debug(f"Message saved to spillover: {message.get('event_type')}")
+        except Exception as e:
+            logger.error(f"Spillover save failed: {e}")
+
+    # -------------------------------------------------------
+    # SPILLOVER LOAD (Recovery from disk)
+    # -------------------------------------------------------
+    def _load_spillover(self):
+        """Load spillover messages from disk (recovery on startup)."""
+        if not os.path.exists(SPILLOVER_FILE):
+            return
+
+        try:
+            logger.info("Restoring spillover queue from disk...")
+            with open(SPILLOVER_FILE, "r") as f:
+                for line in f:
+                    try:
+                        self._q.put(json.loads(line.strip()))
+                    except json.JSONDecodeError:
+                        continue
+            os.remove(SPILLOVER_FILE)
+            logger.info("Spillover restored and cleaned.")
+        except Exception as e:
+            logger.error(f"Spillover load failed: {e}")
+
+    # -------------------------------------------------------
+    # SAFE WORKER LOOP (auto-restarting on crash)
+    # -------------------------------------------------------
+    def _safe_worker_loop(self):
+        """Worker loop that auto-restarts on crash."""
+        while True:
+            try:
+                self._worker_loop()
+                return
+            except Exception as e:
+                logger.error(f"Worker crashed: {e}")
+                time.sleep(0.5)
+                logger.info("Restarting worker...")
+
+    # -------------------------------------------------------
+    # REAL WORKER LOOP (batch processing)
+    # -------------------------------------------------------
+    def _worker_loop(self):
+        """Main worker loop with batch accumulation and send."""
+        batch = []
+        while True:
+            try:
+                msg = self._q.get(timeout=0.2)
+
+                # Shutdown signal
+                if msg is self.SHUTDOWN_SENTINEL:
+                    return
+
+                batch.append(msg)
+
+            except queue.Empty:
+                pass
+
+            # Batch conditions: flush if batch size >= 10 or time-based (every ~1s)
+            flush_size = len(batch) >= 10
+            flush_time = batch and (time.time() % 1 < 0.15)
+
+            if flush_size or flush_time:
+                try:
+                    self._send_batch(batch)
+                except RuntimeError as e:
+                    if "Event loop is closed" in str(e):
+                        # Safe ignore — Windows cleanup issue
+                        return
+                    raise
+                batch = []
+
+    # -------------------------------------------------------
+    # FORCE FLUSH
+    # -------------------------------------------------------
+    def force_flush(self):
+        """Synchronously send all remaining messages (used on shutdown)."""
+        batch = []
+        while not self._q.empty():
+            try:
+                msg = self._q.get_nowait()
+                if msg is not self.SHUTDOWN_SENTINEL:
+                    batch.append(msg)
+            except Exception:
+                break
+
+        if batch:
+            self._send_batch(batch)
+
+        time.sleep(0.1)
+
+    # -------------------------------------------------------
+    # AWS INIT (Lazy initialization with fallback)
+    # -------------------------------------------------------
+    def _auto_initialize(self):
+        """Initialize AWS SQS client from config. Fails gracefully if misconfigured."""
+        if self._init_once and self.client:
+            return
+
+        cfg = get_sqs_config()
+        self.queue_url = cfg.get("aws_sqs_url")
+
+        if not self.queue_url:
+            logger.info("No SQS URL configured → SQS disabled.")
+            self.sqs_enabled = False
+            self._init_once = True
+            return
+
+        try:
+            session = boto3.Session(
+                profile_name=cfg.get("aws_profile"),
+                region_name=cfg.get("aws_region")
+            )
+            self.client = session.client("sqs")
+
+            # Test connection
+            self.client.get_queue_attributes(
+                QueueUrl=self.queue_url,
+                AttributeNames=["QueueArn"]
+            )
+
+            self.sqs_enabled = True
+            logger.info(f"SQS connected → {self.queue_url}")
+
+        except Exception as e:
+            logger.warning(f"SQS initialization failed: {e} → Spillover enabled.")
+            self.client = None
+            self.sqs_enabled = False
+
+        self._init_once = True
+
+    # -------------------------------------------------------
+    # PUBLIC SEND API
+    # -------------------------------------------------------
+    def send(self, message: Optional[Dict[str, Any]]) -> bool:
+        """
+        Queue a message for batched send to SQS.
+        Non-blocking; if SQS is down, spillover to disk.
+        
+        Args:
+            message: Dictionary message to send
+            
+        Returns:
+            bool: True if queued successfully
+        """
+        if not message:
+            return False
+
+        if not self.sqs_enabled:
+            self._auto_initialize()
+
+        try:
+            self._q.put_nowait(message)
+            return True
+        except Exception as e:
+            logger.debug(f"Queue full → spillover: {e}")
+            self._spillover_save(message)
+            return False
+
+    def send_immediate(self, message: Optional[Dict[str, Any]]) -> bool:
+        """
+        Send message immediately without batching.
+        Use for critical messages like trace_end.
+        Falls back to spillover if SQS unavailable.
+        
+        Args:
+            message: Dictionary message to send
+            
+        Returns:
+            bool: True if sent successfully
+        """
+        if not message:
+            return False
+
+        if not self.sqs_enabled:
+            self._auto_initialize()
+
+        if not self.client:
+            logger.debug("SQS unavailable for immediate send → spillover")
+            self._spillover_save(message)
+            return False
+
+        try:
+            self.client.send_message(
+                QueueUrl=self.queue_url,
+                MessageBody=json.dumps(message)
+            )
+            logger.debug(f"Immediate send OK: {message.get('event_type')}")
+            return True
+        except Exception as e:
+            logger.warning(f"Immediate send failed: {e} → spillover")
+            self._spillover_save(message)
+            return False
+
+    # -------------------------------------------------------
+    # BATCH SEND
+    # -------------------------------------------------------
+    def _send_batch(self, batch):
+        """Send a batch of messages to SQS. Retry individually on failure."""
+        if not batch:
+            return
+
+        if not self.client:
+            self._auto_initialize()
+
+        if not self.client:
+            logger.debug(f"SQS unavailable → spillover {len(batch)} messages")
+            for msg in batch:
+                self._spillover_save(msg)
+            return
+
+        entries = [
+            {"Id": str(i), "MessageBody": json.dumps(msg)}
+            for i, msg in enumerate(batch[:10])  # Max 10 per batch API call
+        ]
+
+        try:
+            response = self.client.send_message_batch(
+                QueueUrl=self.queue_url,
+                Entries=entries
+            )
+            logger.debug(f"Batch send OK: {len(entries)} messages")
+        except Exception as e:
+            logger.warning(f"Batch send failed: {e} → retry individual")
+            self._retry_individual(batch)
+
+    # -------------------------------------------------------
+    # RETRY INDIVIDUAL MESSAGES
+    # -------------------------------------------------------
+    def _retry_individual(self, batch):
+        """Retry individual messages if batch send fails."""
+        # Ensure SQS client exists
+        if not self.client:
+            self._auto_initialize()
+
+        client = self.client
+        if not client:
+            logger.debug(f"Client unavailable → spilling {len(batch)} messages")
+            for msg in batch:
+                self._spillover_save(msg)
+            return
+
+        for msg in batch:
+            try:
+                client.send_message(
+                    QueueUrl=self.queue_url,
+                    MessageBody=json.dumps(msg)
+                )
+                logger.debug(f"Individual send OK: {msg.get('event_type')}")
+            except Exception as e:
+                logger.warning(f"Individual send FAILED: {e} → spillover")
+                self._spillover_save(msg)
+
+
+# -------------------------------------------------------
+# SINGLETON INSTANCE
+# -------------------------------------------------------
+_sqs_instance = _LLMOpsObservabilitySQS()
+
+
+def send_to_sqs(bundle: Optional[Dict[str, Any]]) -> bool:
+    """Send a message to SQS queue (batched)."""
+    return _sqs_instance.send(bundle)
+
+
+def send_to_sqs_immediate(bundle: Optional[Dict[str, Any]]) -> bool:
+    """Send a message to SQS queue (immediate, no batching)."""
+    return _sqs_instance.send_immediate(bundle)
+
+
+def flush_sqs():
+    """Force flush all pending messages to SQS."""
+    return _sqs_instance.force_flush()
+
+
+def is_sqs_enabled() -> bool:
+    """Check if SQS is enabled and initialized."""
+    return _sqs_instance.sqs_enabled
+
+
+# -------------------------------------------------------
+# AUTO-FLUSH + CLEAN SHUTDOWN
+# -------------------------------------------------------
+def _cleanup_at_exit():
+    """Cleanup handler registered with atexit."""
+    if os.getpid() != MAIN_PID:
+        return
+
+    logger.info("Flushing and shutting down SQS...")
+
+    try:
+        _sqs_instance.shutdown()     # Stop background threads
+        _sqs_instance.force_flush()  # Send remaining messages
+    except Exception as e:
+        logger.error(f"Exit flush failed: {e}")
+
+
+atexit.register(_cleanup_at_exit)

{llmops_observability-10.0.4 → llmops_observability-10.0.5}/src/llmops_observability/trace_manager.py

@@ -1,7 +1,7 @@
 """
 Trace Manager for LLMOps Observability
 Handles tracing and tracking of LLM operations with direct Langfuse integration
-Inspired by veriskGO's trace_manager with instant span sending to Langfuse
+Direct Langfuse integration with SQS event streaming
 """
 from __future__ import annotations
 import uuid
@@ -17,6 +17,7 @@ from datetime import datetime, timezone
 from typing import Optional, Dict, Any, List, Union
 from .models import SpanContext, TraceConfig
 from .config import get_langfuse_client
+from .sqs import send_to_sqs, send_to_sqs_immediate, is_sqs_enabled
 
 # Configure logger
 logger = logging.getLogger(__name__)
@@ -259,6 +260,26 @@ class TraceManager:
                 cls._pending_spans.clear()
             
             logger.info(f"Trace started: {trace_config.trace_name} | Operation: {trace_config.name} | Env: {trace_config.environment} (ID: {trace_id})")
+            
+            # Send trace_start event to SQS (non-blocking)
+            if is_sqs_enabled():
+                trace_start_event = {
+                    "event_type": "trace_start",
+                    "trace_id": trace_id,
+                    "trace_name": trace_config.trace_name,
+                    "operation": trace_config.name,
+                    "timestamp": cls._now(),
+                    "metadata": {
+                        "project_id": trace_config.project_id,
+                        "environment": trace_config.environment,
+                        "user_id": trace_config.user_id,
+                        "session_id": trace_config.session_id,
+                        **(trace_config.metadata or {})
+                    }
+                }
+                send_to_sqs(trace_start_event)
+                logger.debug(f"Trace start event sent to SQS: {trace_id}")
+            
             return trace_id
 
     @classmethod
@@ -384,6 +405,24 @@ class TraceManager:
         with cls._lock:
             cls._end_trace_internal()
         
+        # Send trace_end event to SQS (immediate, critical message)
+        if is_sqs_enabled():
+            trace_end_event = {
+                "event_type": "trace_end",
+                "trace_id": trace_id,
+                "user_id": user_id,
+                "session_id": session_id,
+                "trace_name": trace_name,
+                "trace_input": serialize_value(trace_input),
+                "trace_output": serialize_value(trace_output),
+                "timestamp": cls._now(),
+                "metadata": {
+                    "project_id": cls._active.get("trace_config", {}).project_id if cls._active.get("trace_config") else "unknown"
+                }
+            }
+            send_to_sqs_immediate(trace_end_event)
+            logger.debug(f"Trace end event sent to SQS: {trace_id}")
+        
         logger.info(f"Trace finalized and sent: {trace_name} (ID: {trace_id})")
         return True
 
@@ -704,6 +743,25 @@ def track_function(
                             status_message=str(error) if error else None,
                         )
                         
+                        # Send span event to SQS (non-blocking, independent of Langfuse)
+                        if is_sqs_enabled() and TraceManager.has_active_trace():
+                            trace_id = TraceManager._active.get("trace_id")
+                            if trace_id:
+                                span_event = {
+                                    "event_type": "span",
+                                    "trace_id": trace_id,
+                                    "span_id": obs.id if hasattr(obs, 'id') else "unknown",
+                                    "parent_span_id": None,  # Will be updated by decorator context
+                                    "name": span_name,
+                                    "timestamp": TraceManager._now(),
+                                    "duration_ms": duration_ms,
+                                    "input": input_data,
+                                    "output": output_data,
+                                    "metadata": span_metadata
+                                }
+                                send_to_sqs(span_event)
+                                logger.debug(f"Span event sent to SQS: {span_name}")
+                        
                         # Note: flush happens after context exit
                 
                 # Flush after exiting context

{llmops_observability-10.0.4 → llmops_observability-10.0.5}/src/llmops_observability.egg-info/PKG-INFO

@@ -1,12 +1,13 @@
 Metadata-Version: 2.4
 Name: llmops-observability
-Version: 10.0.4
-Summary: LLMOps Observability SDK with direct Langfuse integration (no SQS/batching)
+Version: 10.0.5
+Summary: LLMOps Observability SDK with direct Langfuse integration and SQS event streaming
 Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 Requires-Dist: langfuse>=2.0.0
 Requires-Dist: httpx
 Requires-Dist: python-dotenv
+Requires-Dist: boto3
 
 # LLMOps Observability SDK
 
@@ -15,7 +16,7 @@ A lightweight Python SDK for LLM observability with **direct Langfuse integratio
 ## Key Features
 
 - ⚡ **Instant Tracing**: Sends traces directly to Langfuse in real-time
-- 🎯 **Simple API**: Same decorators as veriskGO (`@track_function`, `@track_llm_call`)
+- 🎯 **Simple API**: (`@track_function`, `@track_llm_call`)
 - 🚫 **No Complexity**: No SQS queues, no batching, no background workers
 - 🔄 **Sync & Async**: Supports both synchronous and asynchronous functions
 - 🎨 **Provider Agnostic**: Works with any LLM provider (Bedrock, OpenAI, Anthropic, etc.)
@@ -134,7 +135,7 @@ TraceManager.start_trace(
 TraceManager.end_trace()
 ```
 
-**Method 3: Using `finalize_and_send()` (veriskGO-compatible)**
+**Method 3: Using `finalize_and_send()` (llmops-observability)**
 ```python
 # Start trace
 TraceManager.start_trace(name="chat_session")

{llmops_observability-10.0.4 → llmops_observability-10.0.5}/src/llmops_observability.egg-info/SOURCES.txt

@@ -6,6 +6,7 @@ src/llmops_observability/config.py
 src/llmops_observability/llm.py
 src/llmops_observability/models.py
 src/llmops_observability/pricing.py
+src/llmops_observability/sqs.py
 src/llmops_observability/trace_manager.py
 src/llmops_observability.egg-info/PKG-INFO
 src/llmops_observability.egg-info/SOURCES.txt

{llmops_observability-10.0.4 → llmops_observability-10.0.5}/src/llmops_observability.egg-info/requires.txt

@@ -1,3 +1,4 @@
 langfuse>=2.0.0
 httpx
 python-dotenv
+boto3