llmops-observability 8.0.0__py3-none-any.whl

llmops_observability/__init__.py

@@ -0,0 +1,27 @@
+"""
+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.
+"""
+from importlib.metadata import version, PackageNotFoundError
+
+try:
+    __version__ = version("llmops-observability")
+except PackageNotFoundError:
+    __version__ = "0.0.0"
+
+# Core components
+from .trace_manager import TraceManager, track_function
+from .llm import track_llm_call
+from .config import get_langfuse_client, configure
+from .asgi_middleware import LLMOpsASGIMiddleware
+
+__all__ = [
+    "TraceManager",
+    "track_function",
+    "track_llm_call",
+    "get_langfuse_client",
+    "configure",
+    "LLMOpsASGIMiddleware",
+    "__version__",
+]

llmops_observability/asgi_middleware.py

@@ -0,0 +1,146 @@
+"""
+ASGI Middleware for LLMOps Observability
+Automatic tracing for FastAPI and other ASGI applications
+Based on veriskGO's asgi_middleware with direct Langfuse integration
+"""
+import uuid
+import time
+import os
+import socket
+from .trace_manager import TraceManager
+
+
+class LLMOpsASGIMiddleware:
+    """
+    ASGI middleware for automatic tracing of HTTP requests.
+    
+    Usage with FastAPI:
+        from fastapi import FastAPI
+        from llmops_observability.asgi_middleware import LLMOpsASGIMiddleware
+        
+        app = FastAPI()
+        app.add_middleware(LLMOpsASGIMiddleware, service_name="my_api")
+        
+        @app.get("/")
+        async def root():
+            return {"message": "Hello World"}
+    """
+
+    def __init__(self, app, service_name="llmops_service"):
+        """
+        Initialize the ASGI middleware.
+        
+        Args:
+            app: ASGI application instance
+            service_name: Name of the service (used in trace naming)
+        """
+        self.app = app
+        self.service_name = service_name
+
+    def get_trace_name(self):
+        """
+        Generate a trace name based on project and hostname.
+        
+        Returns:
+            str: Trace name in format "project_hostname"
+        """
+        project = os.path.basename(os.getcwd())
+        hostname = socket.gethostname()
+        return f"{project}_{hostname}"
+
+    async def __call__(self, scope, receive, send):
+        """
+        ASGI middleware entry point.
+        
+        Args:
+            scope: ASGI scope dictionary
+            receive: ASGI receive callable
+            send: ASGI send callable
+        """
+        # We only trace HTTP traffic
+        if scope["type"] != "http":
+            await self.app(scope, receive, send)
+            return
+
+        method = scope.get("method", "UNKNOWN")
+        path = scope.get("path", "UNKNOWN")
+
+        # Extract headers (optional user/session identification)
+        headers = {k.decode(): v.decode() for k, v in scope.get("headers", [])}
+        user_id = headers.get("x-user-id", "anonymous")
+        session_id = headers.get("x-session-id", str(uuid.uuid4()))
+        
+        # Generate trace name
+        trace_name = self.get_trace_name()
+
+        # Start trace with metadata
+        TraceManager.start_trace(
+            trace_name,
+            metadata={
+                "path": path,
+                "method": method,
+                "user_id": user_id,
+                "session_id": session_id,
+                "service": self.service_name,
+            },
+            user_id=user_id,
+            session_id=session_id,
+        )
+
+        start_time = time.time()
+        response_body = None
+        status_code = None
+
+        async def send_wrapper(message):
+            """Wrapper to capture response data"""
+            nonlocal response_body, status_code
+
+            # Capture response status
+            if message["type"] == "http.response.start":
+                status_code = message.get("status")
+
+            # Capture response body
+            if message["type"] == "http.response.body":
+                body = message.get("body")
+                try:
+                    response_body = body.decode() if body else None
+                except Exception:
+                    response_body = str(body) if body else None
+
+            await send(message)
+
+        try:
+            # Execute the application
+            await self.app(scope, receive, send_wrapper)
+        except Exception as exc:
+            # Trace the exception
+            TraceManager.finalize_and_send(
+                user_id=user_id,
+                session_id=session_id,
+                trace_name=f"{trace_name}_error",
+                trace_input={"path": path, "method": method},
+                trace_output={
+                    "error": str(exc),
+                    "error_type": type(exc).__name__,
+                },
+            )
+            raise
+
+        # Normal completion - finalize trace with input/output
+        latency_ms = int((time.time() - start_time) * 1000)
+        
+        TraceManager.finalize_and_send(
+            user_id=user_id,
+            session_id=session_id,
+            trace_name=trace_name,
+            trace_input={
+                "path": path,
+                "method": method,
+                "headers": dict(headers),  # Include all headers
+            },
+            trace_output={
+                "status_code": status_code,
+                "response": response_body,
+                "latency_ms": latency_ms,
+            },
+        )

llmops_observability/config.py

@@ -0,0 +1,79 @@
+"""
+Configuration management for LLMOps Observability
+Direct Langfuse client configuration
+"""
+import os
+from typing import Optional
+from langfuse import Langfuse
+import httpx
+from dotenv import load_dotenv
+
+# Load environment variables
+load_dotenv()
+
+# Global Langfuse client
+_langfuse_client: Optional[Langfuse] = None
+
+
+def get_langfuse_client() -> Langfuse:
+    """
+    Get or create the global Langfuse client.
+    
+    Environment variables:
+        - LANGFUSE_PUBLIC_KEY: Langfuse public key
+        - LANGFUSE_SECRET_KEY: Langfuse secret key
+        - LANGFUSE_BASE_URL: Langfuse base URL
+        - LANGFUSE_VERIFY_SSL: Whether to verify SSL (default: false)
+    
+    Returns:
+        Langfuse: Configured Langfuse client
+    """
+    global _langfuse_client
+    
+    if _langfuse_client is None:
+        verify_ssl = os.getenv("LANGFUSE_VERIFY_SSL", "false").lower() == "false"
+        
+        # Create custom HTTP client with optional SSL verification
+        httpx_client = httpx.Client(verify=verify_ssl) if not verify_ssl else None
+        
+        _langfuse_client = Langfuse(
+            public_key=os.getenv("LANGFUSE_PUBLIC_KEY","pk-lf-675b5c31-775e-4cfc-89b7-7aea0219aab1"),
+            secret_key=os.getenv("LANGFUSE_SECRET_KEY","sk-lf-bc2e15c2-2dab-44ba-a4f5-66c69087f404"),
+            base_url=os.getenv("LANGFUSE_BASE_URL","https://internal-k8s-langfuse-langfuse-6657f5b8d5-481261872.us-east-1.elb.amazonaws.com"),
+            httpx_client=httpx_client,
+        )
+        
+        # Print the actual base URL being used (including default)
+        actual_base_url = os.getenv("LANGFUSE_BASE_URL") or "https://internal-k8s-langfuse-langfuse-6657f5b8d5-481261872.us-east-1.elb.amazonaws.com"
+        print(f"[LLMOps-Observability] Langfuse client initialized: {actual_base_url}")
+    
+    return _langfuse_client
+
+
+def configure(
+    public_key: Optional[str] = None,
+    secret_key: Optional[str] = None,
+    base_url: Optional[str] = None,
+    verify_ssl: bool = False
+):
+    """
+    Manually configure Langfuse client.
+    
+    Args:
+        public_key: Langfuse public key
+        secret_key: Langfuse secret key
+        base_url: Langfuse base URL
+        verify_ssl: Whether to verify SSL certificates
+    """
+    global _langfuse_client
+    
+    httpx_client = httpx.Client(verify=verify_ssl) if not verify_ssl else None
+    
+    _langfuse_client = Langfuse(
+        public_key=public_key,
+        secret_key=secret_key,
+        base_url=base_url,
+        httpx_client=httpx_client,
+    )
+    
+    print(f"[LLMOps-Observability] Langfuse client configured: {base_url}")