magic-lab-observer 0.1.1__tar.gz

magic_lab_observer-0.1.1/.gitignore

@@ -0,0 +1,68 @@
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+
+# Virtual environments
+.venv/
+venv/
+ENV/
+
+# IDE
+.vscode/
+.idea/
+*.swp
+*.swo
+*~
+
+# Testing
+.coverage
+htmlcov/
+.pytest_cache/
+.mypy_cache/
+
+# Node.js
+node_modules/
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+
+# Build
+dist/
+build/
+*.tsbuildinfo
+
+# Environment
+.env
+.env.local
+.env.*.local
+
+# Podman
+podman-compose.override.yml
+
+# Database
+*.db
+*.sqlite3
+.observer-state/
+
+# OS
+.DS_Store
+Thumbs.db
+

magic_lab_observer-0.1.1/PKG-INFO

@@ -0,0 +1,75 @@
+Metadata-Version: 2.4
+Name: magic-lab-observer
+Version: 0.1.1
+Summary: Python SDK for LLM Observatory - Open-source LLM observability
+Project-URL: Homepage, https://github.com/Magic-Lab-Studio/observer
+Project-URL: Repository, https://github.com/Magic-Lab-Studio/observer.git
+Project-URL: Issues, https://github.com/Magic-Lab-Studio/observer/issues
+Author: LLM Observatory Contributors
+License-Expression: Apache-2.0
+Keywords: anthropic,llm,observability,openai,tracing
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.10
+Requires-Dist: httpx>=0.27.0
+Provides-Extra: all
+Requires-Dist: anthropic>=0.20.0; extra == 'all'
+Requires-Dist: langchain-core>=0.2.0; extra == 'all'
+Requires-Dist: openai>=1.0.0; extra == 'all'
+Provides-Extra: anthropic
+Requires-Dist: anthropic>=0.20.0; extra == 'anthropic'
+Provides-Extra: dev
+Requires-Dist: mypy>=1.10; extra == 'dev'
+Requires-Dist: pytest-cov>=5.0; extra == 'dev'
+Requires-Dist: pytest>=8.0; extra == 'dev'
+Requires-Dist: ruff>=0.5; extra == 'dev'
+Provides-Extra: langchain
+Requires-Dist: langchain-core>=0.2.0; extra == 'langchain'
+Provides-Extra: openai
+Requires-Dist: openai>=1.0.0; extra == 'openai'
+Description-Content-Type: text/markdown
+
+# LLM Observatory Python SDK
+
+Open-source LLM observability SDK for tracing and monitoring AI applications.
+
+## Installation
+
+```bash
+pip install magic-lab-observer
+```
+
+With optional integrations:
+
+```bash
+pip install magic-lab-observer[openai,anthropic,langchain]
+```
+
+## Quick Start
+
+The distribution name is `magic-lab-observer`; the stable Python import remains
+`llm_observatory`.
+
+```python
+from llm_observatory import instrument, trace
+
+# Auto-instrument LLM libraries
+instrument(openai=True, anthropic=True)
+
+# Or manually trace functions
+@trace(name="summarize")
+def summarize(text: str):
+    return openai.chat.completions.create(
+        model="gpt-4",
+        messages=[{"role": "user", "content": text}]
+    )
+```
+
+## License
+
+Apache License 2.0

magic_lab_observer-0.1.1/README.md

@@ -0,0 +1,39 @@
+# LLM Observatory Python SDK
+
+Open-source LLM observability SDK for tracing and monitoring AI applications.
+
+## Installation
+
+```bash
+pip install magic-lab-observer
+```
+
+With optional integrations:
+
+```bash
+pip install magic-lab-observer[openai,anthropic,langchain]
+```
+
+## Quick Start
+
+The distribution name is `magic-lab-observer`; the stable Python import remains
+`llm_observatory`.
+
+```python
+from llm_observatory import instrument, trace
+
+# Auto-instrument LLM libraries
+instrument(openai=True, anthropic=True)
+
+# Or manually trace functions
+@trace(name="summarize")
+def summarize(text: str):
+    return openai.chat.completions.create(
+        model="gpt-4",
+        messages=[{"role": "user", "content": text}]
+    )
+```
+
+## License
+
+Apache License 2.0

magic_lab_observer-0.1.1/pyproject.toml

@@ -0,0 +1,63 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "magic-lab-observer"
+version = "0.1.1"
+description = "Python SDK for LLM Observatory - Open-source LLM observability"
+readme = "README.md"
+license = "Apache-2.0"
+requires-python = ">=3.10"
+authors = [
+    { name = "LLM Observatory Contributors" }
+]
+keywords = ["llm", "observability", "tracing", "openai", "anthropic"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: Apache Software License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+]
+
+dependencies = [
+    "httpx>=0.27.0",
+]
+
+[project.urls]
+Homepage = "https://github.com/Magic-Lab-Studio/observer"
+Repository = "https://github.com/Magic-Lab-Studio/observer.git"
+Issues = "https://github.com/Magic-Lab-Studio/observer/issues"
+
+[project.optional-dependencies]
+openai = ["openai>=1.0.0"]
+anthropic = ["anthropic>=0.20.0"]
+langchain = ["langchain-core>=0.2.0"]
+all = [
+    "openai>=1.0.0",
+    "anthropic>=0.20.0",
+    "langchain-core>=0.2.0",
+]
+dev = [
+    "pytest>=8.0",
+    "pytest-cov>=5.0",
+    "ruff>=0.5",
+    "mypy>=1.10",
+]
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/llm_observatory"]
+
+[tool.ruff]
+line-length = 100
+target-version = "py310"
+
+[tool.ruff.lint]
+select = ["E", "F", "I", "N", "W", "UP"]
+
+[tool.mypy]
+python_version = "3.10"
+strict = true

magic_lab_observer-0.1.1/src/llm_observatory/__init__.py

@@ -0,0 +1,32 @@
+"""LLM Observatory Python SDK - Open-source LLM observability."""
+
+from llm_observatory.exporters.otlp import OTLPExporter
+from llm_observatory.instrumentors import instrument, uninstrument
+from llm_observatory.pricing import MODEL_PRICING, calculate_cost, get_model_pricing
+from llm_observatory.tracer import (
+    Span,
+    SpanStatus,
+    TokenUsage,
+    Tracer,
+    get_tracer,
+    set_tracer,
+    trace,
+)
+
+__version__ = "0.1.1"
+
+__all__ = [
+    "Tracer",
+    "Span",
+    "SpanStatus",
+    "TokenUsage",
+    "trace",
+    "get_tracer",
+    "set_tracer",
+    "instrument",
+    "uninstrument",
+    "calculate_cost",
+    "get_model_pricing",
+    "MODEL_PRICING",
+    "OTLPExporter",
+]

magic_lab_observer-0.1.1/src/llm_observatory/exporters/__init__.py

@@ -0,0 +1,23 @@
+"""Exporters for sending traces to backends."""
+
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from typing import Any
+
+
+class BaseExporter(ABC):
+    """Base class for trace exporters."""
+
+    @abstractmethod
+    def export(self, spans: list[dict[str, Any]]) -> None:
+        """Export spans to the backend.
+
+        Args:
+            spans: List of span dictionaries to export.
+        """
+        ...
+
+    def flush(self) -> None:
+        """Flush any buffered spans."""
+        pass

magic_lab_observer-0.1.1/src/llm_observatory/exporters/otlp.py

@@ -0,0 +1,90 @@
+"""OTLP HTTP exporter for sending traces to observatory backend."""
+
+from __future__ import annotations
+
+import logging
+from typing import Any
+
+import httpx
+
+from llm_observatory.exporters import BaseExporter
+
+logger = logging.getLogger(__name__)
+
+
+class OTLPExporter(BaseExporter):
+    """Exports traces to an OTLP-compatible backend via HTTP."""
+
+    def __init__(
+        self,
+        endpoint: str = "http://localhost:8000",
+        api_key: str | None = None,
+        timeout: float = 10.0,
+        max_retries: int = 3,
+    ) -> None:
+        """Initialize the exporter.
+
+        Args:
+            endpoint: Backend endpoint URL.
+            api_key: Optional API key for authentication.
+            timeout: Request timeout in seconds.
+            max_retries: Maximum number of retries on failure.
+        """
+        self.endpoint = endpoint.rstrip("/")
+        self.api_key = api_key
+        self.timeout = timeout
+        self.max_retries = max_retries
+        self._client = httpx.Client(timeout=timeout)
+
+    def export(self, spans: list[dict[str, Any]]) -> None:
+        """Export spans to the backend.
+
+        Args:
+            spans: List of span dictionaries to export.
+        """
+        headers = {"Content-Type": "application/json"}
+        if self.api_key:
+            headers["Authorization"] = f"Bearer {self.api_key}"
+
+        for attempt in range(self.max_retries):
+            try:
+                response = self._client.post(
+                    f"{self.endpoint}/v1/traces/batch",
+                    json={"spans": spans},
+                    headers=headers,
+                )
+                response.raise_for_status()
+                logger.debug(f"Exported {len(spans)} spans successfully")
+                return
+            except httpx.HTTPStatusError as e:
+                logger.warning(
+                    f"Export failed (attempt {attempt + 1}/{self.max_retries}): "
+                    f"HTTP {e.response.status_code} - {e.response.text}"
+                )
+                if attempt == self.max_retries - 1:
+                    msg = (
+                        f"Export failed after {self.max_retries} attempts, "
+                        f"dropping {len(spans)} spans"
+                    )
+                    logger.error(msg)
+            except httpx.HTTPError as e:
+                logger.warning(
+                    f"Export failed (attempt {attempt + 1}/{self.max_retries}): {e}"
+                )
+                if attempt == self.max_retries - 1:
+                    msg = (
+                        f"Export failed after {self.max_retries} attempts, "
+                        f"dropping {len(spans)} spans"
+                    )
+                    logger.error(msg)
+
+    def flush(self) -> None:
+        """Flush any buffered spans."""
+        self._client.close()
+
+    def __del__(self) -> None:
+        """Clean up the client."""
+        try:
+            self._client.close()
+        except Exception:
+            pass

magic_lab_observer-0.1.1/src/llm_observatory/instrumentors/__init__.py

@@ -0,0 +1,57 @@
+"""Auto-instrumentation for LLM libraries."""
+
+from __future__ import annotations
+
+from typing import Any
+
+# Store instrumentor instances for uninstrument()
+_active_instrumentors: list[Any] = []
+
+
+def instrument(
+    openai: bool = False,
+    anthropic: bool = False,
+    langchain: bool = False,
+    **kwargs: Any,
+) -> None:
+    """Auto-instrument LLM libraries.
+
+    Args:
+        openai: Enable OpenAI instrumentation.
+        anthropic: Enable Anthropic instrumentation.
+        langchain: Enable LangChain instrumentation.
+        **kwargs: Additional configuration options.
+    """
+    if openai:
+        from llm_observatory.instrumentors.openai import OpenAIInstrumentor
+
+        inst = OpenAIInstrumentor()
+        inst.instrument()
+        _active_instrumentors.append(inst)
+
+    if anthropic:
+        from llm_observatory.instrumentors.anthropic import AnthropicInstrumentor
+
+        inst = AnthropicInstrumentor()
+        inst.instrument()
+        _active_instrumentors.append(inst)
+
+    if langchain:
+        try:
+            from llm_observatory.instrumentors.langchain import LangChainInstrumentor
+
+            inst = LangChainInstrumentor()
+            inst.instrument()
+            _active_instrumentors.append(inst)
+        except ImportError:
+            pass
+
+
+def uninstrument() -> None:
+    """Uninstrument all active instrumentors."""
+    for inst in _active_instrumentors:
+        try:
+            inst.uninstrument()
+        except Exception:
+            pass
+    _active_instrumentors.clear()

magic_lab_observer-0.1.1/src/llm_observatory/instrumentors/anthropic.py

@@ -0,0 +1,135 @@
+"""Anthropic auto-instrumentation."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from llm_observatory.pricing import calculate_cost
+from llm_observatory.tracer import Span, SpanStatus, get_tracer
+
+
+class AnthropicInstrumentor:
+    """Instruments Anthropic API calls to capture traces."""
+
+    def __init__(self) -> None:
+        self._original_sync_create: Any | None = None
+        self._original_async_create: Any | None = None
+
+    def instrument(self) -> None:
+        """Patch Anthropic to capture traces."""
+        try:
+            import anthropic
+
+            # Patch sync messages
+            self._original_sync_create = anthropic.resources.messages.Messages.create
+            anthropic.resources.messages.Messages.create = self._patched_sync_create
+
+            # Patch async messages
+            self._original_async_create = (
+                anthropic.resources.messages.AsyncMessages.create
+            )
+            anthropic.resources.messages.AsyncMessages.create = (
+                self._patched_async_create
+            )
+        except ImportError:
+            pass
+
+    def _build_span(
+        self, model: str, messages: list[dict[str, Any]]
+    ) -> tuple[Span, Any]:
+        """Build a span for an Anthropic call."""
+        tracer = get_tracer()
+        span = tracer.start_span(
+            name="anthropic.messages.create",
+            span_type="llm",
+        )
+        span.set_input({"model": model, "messages": messages})
+        span.set_attribute("gen_ai.system", "anthropic")
+        span.set_attribute("gen_ai.request.model", model)
+        return span, tracer
+
+    def _finish_span(self, span: Span, result: Any, model: str) -> None:
+        """Extract data from result and finish span."""
+        try:
+            # Extract token usage
+            if hasattr(result, "usage"):
+                input_tokens = getattr(result.usage, "input_tokens", 0) or 0
+                output_tokens = getattr(result.usage, "output_tokens", 0) or 0
+                span.set_token_usage(input_tokens, output_tokens)
+
+                # Calculate cost
+                cost = calculate_cost(model, input_tokens, output_tokens)
+                if cost is not None:
+                    span.set_cost(cost)
+
+            # Extract output
+            if hasattr(result, "content") and result.content:
+                content_blocks = []
+                for block in result.content:
+                    block_data = {}
+                    if hasattr(block, "type"):
+                        block_data["type"] = block.type
+                    if hasattr(block, "text"):
+                        block_data["text"] = block.text
+                    content_blocks.append(block_data)
+                span.set_output({"content": content_blocks})
+
+            span.set_attribute("response_id", getattr(result, "id", None))
+            span.set_status(SpanStatus.OK)
+
+        except Exception as e:
+            span.set_status(SpanStatus.ERROR)
+            span.set_attribute("error.message", str(e))
+
+        finally:
+            span.end()
+
+    def _patched_sync_create(self, *args: Any, **kwargs: Any) -> Any:
+        """Patched sync create method."""
+        model = kwargs.get("model", "unknown")
+        messages = kwargs.get("messages", [])
+
+        span, _ = self._build_span(model, messages)
+
+        try:
+            result = self._original_sync_create(*args, **kwargs)
+            self._finish_span(span, result, model)
+            return result
+        except Exception as e:
+            span.set_status(SpanStatus.ERROR)
+            span.set_attribute("error.message", str(e))
+            span.end()
+            raise
+
+    async def _patched_async_create(self, *args: Any, **kwargs: Any) -> Any:
+        """Patched async create method."""
+        model = kwargs.get("model", "unknown")
+        messages = kwargs.get("messages", [])
+
+        span, _ = self._build_span(model, messages)
+
+        try:
+            result = await self._original_async_create(*args, **kwargs)
+            self._finish_span(span, result, model)
+            return result
+        except Exception as e:
+            span.set_status(SpanStatus.ERROR)
+            span.set_attribute("error.message", str(e))
+            span.end()
+            raise
+
+    def uninstrument(self) -> None:
+        """Remove instrumentation."""
+        try:
+            import anthropic
+
+            if self._original_sync_create is not None:
+                anthropic.resources.messages.Messages.create = (
+                    self._original_sync_create
+                )
+            if self._original_async_create is not None:
+                anthropic.resources.messages.AsyncMessages.create = (
+                    self._original_async_create
+                )
+        except ImportError:
+            pass