megflow-observability 0.1.0__tar.gz

megflow_observability-0.1.0/PKG-INFO

@@ -0,0 +1,97 @@
+Metadata-Version: 2.4
+Name: megflow-observability
+Version: 0.1.0
+Summary: Megflow AI API observability SDK — auto-instrument OpenAI and Anthropic calls
+License: MIT
+Project-URL: Homepage, https://observability.megflow.com
+Project-URL: Repository, https://github.com/saleem-megflow/megflow-observe
+Keywords: llm,observability,openai,anthropic,monitoring
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Provides-Extra: openai
+Requires-Dist: openai>=1.0.0; extra == "openai"
+Provides-Extra: anthropic
+Requires-Dist: anthropic>=0.20.0; extra == "anthropic"
+Provides-Extra: all
+Requires-Dist: openai>=1.0.0; extra == "all"
+Requires-Dist: anthropic>=0.20.0; extra == "all"
+
+# megflow-observability
+
+Python SDK for [Megflow AI Observability](https://observability.megflow.com) — track tokens, cost, latency and errors across OpenAI, Anthropic, Gemini and more.
+
+## Install
+
+```bash
+pip install megflow-observability
+```
+
+## Quick start
+
+```python
+from megflow_observability import MegflowObserve
+
+observe = MegflowObserve(api_key="obs_your_key_here")
+
+observe.track(
+    provider="openai",
+    model="gpt-4o",
+    input_tokens=100,
+    output_tokens=50,
+    total_tokens=150,
+    cost_usd=0.00075,
+    latency_ms=320,
+    status_code=200,
+)
+```
+
+## Auto-instrument OpenAI
+
+```python
+from openai import OpenAI
+from megflow_observability import MegflowObserve, wrap_openai
+
+client = wrap_openai(OpenAI(), MegflowObserve(api_key="obs_your_key_here"))
+
+# All calls are tracked automatically
+response = client.chat.completions.create(
+    model="gpt-4o",
+    messages=[{"role": "user", "content": "Hello"}],
+)
+```
+
+## Auto-instrument Anthropic
+
+```python
+import anthropic
+from megflow_observability import MegflowObserve, wrap_anthropic
+
+client = wrap_anthropic(anthropic.Anthropic(), MegflowObserve(api_key="obs_your_key_here"))
+
+response = client.messages.create(
+    model="claude-sonnet-4-6",
+    max_tokens=1024,
+    messages=[{"role": "user", "content": "Hello"}],
+)
+```
+
+## Optional dependencies
+
+```bash
+pip install megflow-observability[openai]      # includes openai
+pip install megflow-observability[anthropic]   # includes anthropic
+pip install megflow-observability[all]         # includes both
+```
+
+## Links
+
+- Dashboard: [observability.megflow.com](https://observability.megflow.com)
+- JS SDK: [npmjs.com/package/megflow-observability](https://www.npmjs.com/package/megflow-observability)

megflow_observability-0.1.0/README.md

@@ -0,0 +1,71 @@
+# megflow-observability
+
+Python SDK for [Megflow AI Observability](https://observability.megflow.com) — track tokens, cost, latency and errors across OpenAI, Anthropic, Gemini and more.
+
+## Install
+
+```bash
+pip install megflow-observability
+```
+
+## Quick start
+
+```python
+from megflow_observability import MegflowObserve
+
+observe = MegflowObserve(api_key="obs_your_key_here")
+
+observe.track(
+    provider="openai",
+    model="gpt-4o",
+    input_tokens=100,
+    output_tokens=50,
+    total_tokens=150,
+    cost_usd=0.00075,
+    latency_ms=320,
+    status_code=200,
+)
+```
+
+## Auto-instrument OpenAI
+
+```python
+from openai import OpenAI
+from megflow_observability import MegflowObserve, wrap_openai
+
+client = wrap_openai(OpenAI(), MegflowObserve(api_key="obs_your_key_here"))
+
+# All calls are tracked automatically
+response = client.chat.completions.create(
+    model="gpt-4o",
+    messages=[{"role": "user", "content": "Hello"}],
+)
+```
+
+## Auto-instrument Anthropic
+
+```python
+import anthropic
+from megflow_observability import MegflowObserve, wrap_anthropic
+
+client = wrap_anthropic(anthropic.Anthropic(), MegflowObserve(api_key="obs_your_key_here"))
+
+response = client.messages.create(
+    model="claude-sonnet-4-6",
+    max_tokens=1024,
+    messages=[{"role": "user", "content": "Hello"}],
+)
+```
+
+## Optional dependencies
+
+```bash
+pip install megflow-observability[openai]      # includes openai
+pip install megflow-observability[anthropic]   # includes anthropic
+pip install megflow-observability[all]         # includes both
+```
+
+## Links
+
+- Dashboard: [observability.megflow.com](https://observability.megflow.com)
+- JS SDK: [npmjs.com/package/megflow-observability](https://www.npmjs.com/package/megflow-observability)

megflow_observability-0.1.0/megflow_observability/__init__.py

@@ -0,0 +1,7 @@
+from .client import MegflowObserve
+from .openai_wrapper import wrap_openai
+from .anthropic_wrapper import wrap_anthropic
+
+__version__ = "0.1.0"
+
+__all__ = ["MegflowObserve", "wrap_openai", "wrap_anthropic", "__version__"]

megflow_observability-0.1.0/megflow_observability/anthropic_wrapper.py

@@ -0,0 +1,74 @@
+from __future__ import annotations
+
+import time
+from datetime import datetime, timezone
+from typing import TYPE_CHECKING, Any
+
+from .pricing import calc_cost
+
+if TYPE_CHECKING:
+    import anthropic
+    from .client import MegflowObserve
+
+
+def wrap_anthropic(client: "anthropic.Anthropic", observe: "MegflowObserve") -> "anthropic.Anthropic":
+    original_create = client.messages.create
+
+    def patched_create(*args: Any, **kwargs: Any) -> Any:
+        start = time.monotonic()
+        model: str = kwargs.get("model", "")
+
+        try:
+            response: Any = original_create(*args, **kwargs)
+
+            # Don't track streaming responses
+            if hasattr(response, "__iter__") and not hasattr(response, "usage"):
+                return response
+
+            latency_ms = int((time.monotonic() - start) * 1000)
+            usage = getattr(response, "usage", None)
+            input_tokens: int = getattr(usage, "input_tokens", 0) or 0
+            output_tokens: int = getattr(usage, "output_tokens", 0) or 0
+            cached_tokens: int = getattr(usage, "cache_read_input_tokens", 0) or 0
+            finish_reason: str = getattr(response, "stop_reason", "") or ""
+
+            observe.track(
+                provider="anthropic",
+                model=model,
+                input_tokens=input_tokens,
+                output_tokens=output_tokens,
+                total_tokens=input_tokens + output_tokens,
+                cached_tokens=cached_tokens,
+                cost_usd=calc_cost("anthropic", model, input_tokens, output_tokens),
+                latency_ms=latency_ms,
+                status_code=200,
+                error="",
+                finish_reason=finish_reason,
+                request_id=getattr(response, "id", "") or "",
+                timestamp=datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ"),
+            )
+
+            return response
+
+        except Exception as exc:
+            latency_ms = int((time.monotonic() - start) * 1000)
+            status_code: int = getattr(exc, "status_code", None) or getattr(exc, "status", 500) or 500
+
+            observe.track(
+                provider="anthropic",
+                model=model,
+                input_tokens=0,
+                output_tokens=0,
+                total_tokens=0,
+                cost_usd=0.0,
+                latency_ms=latency_ms,
+                status_code=status_code,
+                error=str(exc),
+                rate_limit_remaining=0 if status_code == 429 else -1,
+                timestamp=datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ"),
+            )
+
+            raise
+
+    client.messages.create = patched_create  # type: ignore[method-assign]
+    return client

megflow_observability-0.1.0/megflow_observability/client.py

@@ -0,0 +1,84 @@
+from __future__ import annotations
+
+import json
+import threading
+import urllib.request
+import urllib.error
+from datetime import datetime, timezone
+from typing import Any, Dict, Optional
+
+SDK_VERSION = "0.1.0"
+DEFAULT_ENDPOINT = "https://api.observability.megflow.com"
+
+
+class MegflowObserve:
+    def __init__(self, api_key: str, endpoint: str = DEFAULT_ENDPOINT) -> None:
+        self._api_key = api_key
+        self._endpoint = endpoint.rstrip("/")
+
+    def track(
+        self,
+        provider: str,
+        model: str,
+        input_tokens: int,
+        output_tokens: int,
+        total_tokens: int,
+        cost_usd: float,
+        latency_ms: int,
+        status_code: int,
+        error: str = "",
+        finish_reason: str = "",
+        environment: str = "",
+        user_id: str = "",
+        cached_tokens: int = 0,
+        rate_limit_remaining: int = -1,
+        retry_count: int = 0,
+        request_id: str = "",
+        timestamp: Optional[str] = None,
+        metadata: Optional[Dict[str, str]] = None,
+    ) -> None:
+        payload: Dict[str, Any] = {
+            "provider": provider,
+            "model": model,
+            "input_tokens": input_tokens,
+            "output_tokens": output_tokens,
+            "total_tokens": total_tokens,
+            "cached_tokens": cached_tokens,
+            "cost_usd": cost_usd,
+            "latency_ms": latency_ms,
+            "status_code": status_code,
+            "error": error,
+            "finish_reason": finish_reason,
+            "environment": environment,
+            "user_id": user_id,
+            "rate_limit_remaining": rate_limit_remaining,
+            "retry_count": retry_count,
+            "request_id": request_id,
+            "timestamp": timestamp or datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ"),
+            "metadata": {
+                **(metadata or {}),
+                "sdk_version": SDK_VERSION,
+                "sdk_language": "python",
+            },
+        }
+
+        thread = threading.Thread(target=self._send, args=(payload,), daemon=True)
+        thread.start()
+
+    def _send(self, payload: Dict[str, Any]) -> None:
+        try:
+            body = json.dumps(payload).encode()
+            req = urllib.request.Request(
+                url=f"{self._endpoint}/v1/events",
+                data=body,
+                headers={
+                    "Content-Type": "application/json",
+                    "X-API-Key": self._api_key,
+                    "Content-Length": str(len(body)),
+                },
+                method="POST",
+            )
+            with urllib.request.urlopen(req, timeout=5):
+                pass
+        except Exception:
+            pass  # observability must never break customer code

megflow_observability-0.1.0/megflow_observability/openai_wrapper.py

@@ -0,0 +1,82 @@
+from __future__ import annotations
+
+import time
+from datetime import datetime, timezone
+from typing import TYPE_CHECKING, Any
+
+from .pricing import calc_cost
+
+if TYPE_CHECKING:
+    from openai import OpenAI
+    from .client import MegflowObserve
+
+
+def wrap_openai(client: "OpenAI", observe: "MegflowObserve") -> "OpenAI":
+    original_create = client.chat.completions.create
+
+    def patched_create(*args: Any, **kwargs: Any) -> Any:
+        start = time.monotonic()
+        model: str = kwargs.get("model", "")
+
+        try:
+            response: Any = original_create(*args, **kwargs)
+
+            # Don't track streaming responses — chunks have no usage data
+            if hasattr(response, "__iter__") and not hasattr(response, "usage"):
+                return response
+
+            latency_ms = int((time.monotonic() - start) * 1000)
+            input_tokens: int = getattr(getattr(response, "usage", None), "prompt_tokens", 0) or 0
+            output_tokens: int = getattr(getattr(response, "usage", None), "completion_tokens", 0) or 0
+            total_tokens: int = getattr(getattr(response, "usage", None), "total_tokens", 0) or input_tokens + output_tokens
+
+            # Cached tokens (OpenAI prompt_tokens_details)
+            details = getattr(getattr(response, "usage", None), "prompt_tokens_details", None)
+            cached_tokens: int = getattr(details, "cached_tokens", 0) or 0
+
+            # Finish reason
+            choices = getattr(response, "choices", None)
+            finish_reason: str = ""
+            if choices:
+                finish_reason = getattr(choices[0], "finish_reason", "") or ""
+
+            observe.track(
+                provider="openai",
+                model=model,
+                input_tokens=input_tokens,
+                output_tokens=output_tokens,
+                total_tokens=total_tokens,
+                cached_tokens=cached_tokens,
+                cost_usd=calc_cost("openai", model, input_tokens, output_tokens),
+                latency_ms=latency_ms,
+                status_code=200,
+                error="",
+                finish_reason=finish_reason,
+                request_id=getattr(response, "id", "") or "",
+                timestamp=datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ"),
+            )
+
+            return response
+
+        except Exception as exc:
+            latency_ms = int((time.monotonic() - start) * 1000)
+            status_code: int = getattr(exc, "status_code", None) or getattr(exc, "status", 500) or 500
+
+            observe.track(
+                provider="openai",
+                model=model,
+                input_tokens=0,
+                output_tokens=0,
+                total_tokens=0,
+                cost_usd=0.0,
+                latency_ms=latency_ms,
+                status_code=status_code,
+                error=str(exc),
+                rate_limit_remaining=0 if status_code == 429 else -1,
+                timestamp=datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ"),
+            )
+
+            raise
+
+    client.chat.completions.create = patched_create  # type: ignore[method-assign]
+    return client

megflow_observability-0.1.0/megflow_observability/pricing.py

@@ -0,0 +1,69 @@
+from __future__ import annotations
+from typing import Dict, Optional, Tuple
+
+# Cost per 1M tokens [input, output] in USD
+_PRICING: Dict[str, Dict[str, Tuple[float, float]]] = {
+    "openai": {
+        "gpt-4o":                (2.50,  10.00),
+        "gpt-4o-mini":           (0.15,   0.60),
+        "gpt-4-turbo":           (10.00, 30.00),
+        "gpt-4-turbo-preview":   (10.00, 30.00),
+        "gpt-4":                 (30.00, 60.00),
+        "gpt-3.5-turbo":         (0.50,   1.50),
+        "o1":                    (15.00, 60.00),
+        "o1-mini":               (3.00,  12.00),
+        "o3-mini":               (1.10,   4.40),
+    },
+    "anthropic": {
+        "claude-3-5-sonnet-20241022": (3.00,  15.00),
+        "claude-3-5-sonnet-20240620": (3.00,  15.00),
+        "claude-3-5-haiku-20241022":  (0.80,   4.00),
+        "claude-3-opus-20240229":     (15.00, 75.00),
+        "claude-3-sonnet-20240229":   (3.00,  15.00),
+        "claude-3-haiku-20240307":    (0.25,   1.25),
+        "claude-sonnet-4-6":          (3.00,  15.00),
+        "claude-opus-4-8":            (15.00, 75.00),
+        "claude-haiku-4-5-20251001":  (0.80,   4.00),
+    },
+    "gemini": {
+        "gemini-1.5-pro":   (1.25,  5.00),
+        "gemini-1.5-flash": (0.075, 0.30),
+        "gemini-2.0-flash": (0.10,  0.40),
+        "gemini-2.5-pro":   (1.25, 10.00),
+        "gemini-2.5-flash": (0.15,  0.60),
+    },
+    "mistral": {
+        "mistral-large-latest": (2.00, 6.00),
+        "mistral-small-latest": (0.20, 0.60),
+        "mistral-7b-instruct":  (0.25, 0.25),
+    },
+    "groq": {
+        "llama3-8b-8192":     (0.05, 0.10),
+        "llama3-70b-8192":    (0.59, 0.79),
+        "mixtral-8x7b-32768": (0.24, 0.24),
+    },
+    "cohere": {
+        "command-r-plus": (3.00, 15.00),
+        "command-r":      (0.50,  1.50),
+    },
+}
+
+
+def calc_cost(provider: str, model: str, input_tokens: int, output_tokens: int) -> float:
+    provider_pricing = _PRICING.get(provider.lower())
+    if not provider_pricing:
+        return 0.0
+
+    rates: Optional[Tuple[float, float]] = provider_pricing.get(model)
+    if rates is None:
+        # prefix match for versioned model names
+        for k, v in provider_pricing.items():
+            if model.startswith(k) or k.startswith(model):
+                rates = v
+                break
+
+    if rates is None:
+        return 0.0
+
+    input_rate, output_rate = rates
+    return (input_tokens * input_rate + output_tokens * output_rate) / 1_000_000

megflow_observability-0.1.0/megflow_observability.egg-info/PKG-INFO

@@ -0,0 +1,97 @@
+Metadata-Version: 2.4
+Name: megflow-observability
+Version: 0.1.0
+Summary: Megflow AI API observability SDK — auto-instrument OpenAI and Anthropic calls
+License: MIT
+Project-URL: Homepage, https://observability.megflow.com
+Project-URL: Repository, https://github.com/saleem-megflow/megflow-observe
+Keywords: llm,observability,openai,anthropic,monitoring
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Provides-Extra: openai
+Requires-Dist: openai>=1.0.0; extra == "openai"
+Provides-Extra: anthropic
+Requires-Dist: anthropic>=0.20.0; extra == "anthropic"
+Provides-Extra: all
+Requires-Dist: openai>=1.0.0; extra == "all"
+Requires-Dist: anthropic>=0.20.0; extra == "all"
+
+# megflow-observability
+
+Python SDK for [Megflow AI Observability](https://observability.megflow.com) — track tokens, cost, latency and errors across OpenAI, Anthropic, Gemini and more.
+
+## Install
+
+```bash
+pip install megflow-observability
+```
+
+## Quick start
+
+```python
+from megflow_observability import MegflowObserve
+
+observe = MegflowObserve(api_key="obs_your_key_here")
+
+observe.track(
+    provider="openai",
+    model="gpt-4o",
+    input_tokens=100,
+    output_tokens=50,
+    total_tokens=150,
+    cost_usd=0.00075,
+    latency_ms=320,
+    status_code=200,
+)
+```
+
+## Auto-instrument OpenAI
+
+```python
+from openai import OpenAI
+from megflow_observability import MegflowObserve, wrap_openai
+
+client = wrap_openai(OpenAI(), MegflowObserve(api_key="obs_your_key_here"))
+
+# All calls are tracked automatically
+response = client.chat.completions.create(
+    model="gpt-4o",
+    messages=[{"role": "user", "content": "Hello"}],
+)
+```
+
+## Auto-instrument Anthropic
+
+```python
+import anthropic
+from megflow_observability import MegflowObserve, wrap_anthropic
+
+client = wrap_anthropic(anthropic.Anthropic(), MegflowObserve(api_key="obs_your_key_here"))
+
+response = client.messages.create(
+    model="claude-sonnet-4-6",
+    max_tokens=1024,
+    messages=[{"role": "user", "content": "Hello"}],
+)
+```
+
+## Optional dependencies
+
+```bash
+pip install megflow-observability[openai]      # includes openai
+pip install megflow-observability[anthropic]   # includes anthropic
+pip install megflow-observability[all]         # includes both
+```
+
+## Links
+
+- Dashboard: [observability.megflow.com](https://observability.megflow.com)
+- JS SDK: [npmjs.com/package/megflow-observability](https://www.npmjs.com/package/megflow-observability)

megflow_observability-0.1.0/megflow_observability.egg-info/SOURCES.txt

@@ -0,0 +1,12 @@
+README.md
+pyproject.toml
+megflow_observability/__init__.py
+megflow_observability/anthropic_wrapper.py
+megflow_observability/client.py
+megflow_observability/openai_wrapper.py
+megflow_observability/pricing.py
+megflow_observability.egg-info/PKG-INFO
+megflow_observability.egg-info/SOURCES.txt
+megflow_observability.egg-info/dependency_links.txt
+megflow_observability.egg-info/requires.txt
+megflow_observability.egg-info/top_level.txt

megflow_observability-0.1.0/megflow_observability.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

megflow_observability-0.1.0/megflow_observability.egg-info/requires.txt

@@ -0,0 +1,10 @@
+
+[all]
+openai>=1.0.0
+anthropic>=0.20.0
+
+[anthropic]
+anthropic>=0.20.0
+
+[openai]
+openai>=1.0.0

megflow_observability-0.1.0/megflow_observability.egg-info/top_level.txt

@@ -0,0 +1 @@
+megflow_observability

megflow_observability-0.1.0/pyproject.toml

@@ -0,0 +1,35 @@
+[build-system]
+requires = ["setuptools>=61", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "megflow-observability"
+version = "0.1.0"
+description = "Megflow AI API observability SDK — auto-instrument OpenAI and Anthropic calls"
+readme = "README.md"
+requires-python = ">=3.8"
+license = { text = "MIT" }
+keywords = ["llm", "observability", "openai", "anthropic", "monitoring"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.8",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+]
+
+[project.optional-dependencies]
+openai = ["openai>=1.0.0"]
+anthropic = ["anthropic>=0.20.0"]
+all = ["openai>=1.0.0", "anthropic>=0.20.0"]
+
+[project.urls]
+Homepage = "https://observability.megflow.com"
+Repository = "https://github.com/saleem-megflow/megflow-observe"
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["megflow_observability*"]

megflow_observability-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+