errivanta 0.2.0__tar.gz

errivanta-0.2.0/PKG-INFO

@@ -0,0 +1,17 @@
+Metadata-Version: 2.4
+Name: errivanta
+Version: 0.2.0
+Summary: Official Python SDK & FastAPI Middleware for Errivanta APM & Observability Platform
+Home-page: https://github.com/codesbyaditya/errivanta
+Author: Errivanta Team
+Author-email: errivanta@gmail.com
+Requires-Python: >=3.9
+Requires-Dist: httpx>=0.27.0
+Requires-Dist: pydantic>=2.0.0
+Requires-Dist: starlette>=0.36.0
+Dynamic: author
+Dynamic: author-email
+Dynamic: home-page
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary

errivanta-0.2.0/README.md

@@ -0,0 +1,48 @@
+# Errivanta Python SDK (`errivanta`)
+
+Official Python SDK and non-blocking FastAPI middleware for the **Errivanta Observability & Monitoring Platform**.
+
+---
+
+## 📦 Installation
+
+```bash
+pip install errivanta
+```
+
+---
+
+## ⚡ Quickstart
+
+Integrate Errivanta into any FastAPI or Starlette application in under 30 seconds:
+
+```python
+from fastapi import FastAPI
+from errivanta import Errivanta
+
+app = FastAPI(title="My Microservice")
+
+# Initialize Errivanta monitoring
+monitor = Errivanta(
+    service_name="payment-service",
+    api_key="your_organization_api_key",
+    monitoring_url="https://your-errivanta-api.onrender.com"
+)
+monitor.init_app(app)
+
+@app.get("/health")
+def health():
+    return {"status": "ok"}
+
+@app.post("/payments/process")
+def process_payment():
+    return {"status": "success", "amount": 100}
+```
+
+---
+
+## 🛡️ Non-Blocking & Fault Tolerant
+
+- **Zero-Latency Overhead**: Telemetry events are dispatched in asynchronous fire-and-forget background tasks.
+- **Fail-Safe**: If the monitoring server is unreachable or times out, exceptions are safely swallowed so your application never crashes or slows down.
+- **Selective Route Filtering**: Automatically skips `/health`, `/docs`, and `/openapi.json` to keep metric logs clean.

errivanta-0.2.0/errivanta/__init__.py

@@ -0,0 +1,69 @@
+from typing import Optional, List
+from errivanta.client import ErrivantaClient, ServiceWatchClient
+from errivanta.middleware import ErrivantaMiddleware, ServiceWatchMiddleware
+from errivanta.models import TelemetryEvent
+
+__version__ = "0.2.0"
+__all__ = [
+    "Errivanta",
+    "ErrivantaClient",
+    "ErrivantaMiddleware",
+    "TelemetryEvent",
+    "ServiceWatch",
+    "ServiceWatchClient",
+    "ServiceWatchMiddleware",
+]
+
+
+class Errivanta:
+    """
+    Main entry point for integrating Errivanta into a Python/FastAPI service.
+
+    Example usage:
+    ```python
+    from fastapi import FastAPI
+    from errivanta import Errivanta
+
+    app = FastAPI()
+
+    monitor = Errivanta(
+        service_name="payment-service",
+        api_key="sw_live_YOUR_KEY",
+        monitoring_url="http://localhost:8001"
+    )
+    monitor.init_app(app)
+    ```
+    """
+
+    def __init__(
+        self,
+        service_name: str,
+        api_key: str,
+        monitoring_url: str = "http://localhost:8001",
+        timeout: float = 2.0,
+        skip_paths: Optional[List[str]] = None,
+    ):
+        self.service_name = service_name
+        self.api_key = api_key
+        self.monitoring_url = monitoring_url.rstrip("/")
+        self.skip_paths = skip_paths or []
+        self.client = ErrivantaClient(
+            api_key=self.api_key,
+            monitoring_url=self.monitoring_url,
+            timeout_seconds=timeout,
+        )
+
+    def init_app(self, app) -> None:
+        """
+        Attaches the Errivanta monitoring middleware to the provided FastAPI / Starlette app.
+        """
+        app.add_middleware(
+            ErrivantaMiddleware,
+            service_name=self.service_name,
+            client=self.client,
+            skip_paths=self.skip_paths,
+        )
+
+
+# Backward compatibility alias
+ServiceWatch = Errivanta

errivanta-0.2.0/errivanta/client.py

@@ -0,0 +1,80 @@
+import logging
+from typing import Optional
+import httpx
+from errivanta.models import TelemetryEvent
+
+logger = logging.getLogger("errivanta")
+
+
+class ErrivantaClient:
+    """
+    HTTP client responsible for dispatching telemetry events to the Errivanta Monitoring API.
+    Designed with strict timeouts and error-swallowing to ensure customer applications never crash.
+    """
+
+    def __init__(
+        self,
+        api_key: str,
+        monitoring_url: str = "http://localhost:8001",
+        timeout_seconds: float = 2.0,
+    ):
+        self.api_key = api_key
+        self.monitoring_url = monitoring_url.rstrip("/")
+        self.events_endpoint = f"{self.monitoring_url}/api/v1/events"
+        self.timeout = timeout_seconds
+
+    async def send_event_async(self, event: TelemetryEvent) -> bool:
+        """
+        Asynchronously sends a telemetry event to the Errivanta API.
+        Returns True if successful, False if failed. Never raises exceptions.
+        """
+        headers = {
+            "Content-Type": "application/json",
+            "X-API-Key": self.api_key,
+        }
+        try:
+            async with httpx.AsyncClient(timeout=self.timeout) as client:
+                response = await client.post(
+                    self.events_endpoint,
+                    json=event.model_dump(),
+                    headers=headers,
+                )
+                if response.status_code not in (200, 201):
+                    logger.warning(
+                        f"[Errivanta] Failed to deliver telemetry: HTTP {response.status_code} - {response.text}"
+                    )
+                    return False
+                return True
+        except Exception as exc:
+            # Graceful degradation: Log a warning and swallow exception so customer app is unaffected
+            logger.warning(f"[Errivanta] Telemetry delivery error (gracefully ignored): {exc}")
+            return False
+
+    def send_event_sync(self, event: TelemetryEvent) -> bool:
+        """
+        Synchronous fallback for sending telemetry events.
+        """
+        headers = {
+            "Content-Type": "application/json",
+            "X-API-Key": self.api_key,
+        }
+        try:
+            with httpx.Client(timeout=self.timeout) as client:
+                response = client.post(
+                    self.events_endpoint,
+                    json=event.model_dump(),
+                    headers=headers,
+                )
+                if response.status_code not in (200, 201):
+                    logger.warning(
+                        f"[Errivanta] Failed to deliver telemetry: HTTP {response.status_code} - {response.text}"
+                    )
+                    return False
+                return True
+        except Exception as exc:
+            logger.warning(f"[Errivanta] Telemetry delivery error (gracefully ignored): {exc}")
+            return False
+
+
+# Backward compatibility alias
+ServiceWatchClient = ErrivantaClient

errivanta-0.2.0/errivanta/middleware.py

@@ -0,0 +1,79 @@
+import time
+import asyncio
+import logging
+from datetime import datetime, timezone
+from typing import List, Optional
+from starlette.middleware.base import BaseHTTPMiddleware
+from starlette.requests import Request
+from starlette.responses import Response
+
+from errivanta.client import ErrivantaClient
+from errivanta.models import TelemetryEvent
+
+logger = logging.getLogger("errivanta")
+
+
+class ErrivantaMiddleware(BaseHTTPMiddleware):
+    """
+    FastAPI / Starlette middleware that intercepts every HTTP request,
+    calculates execution latency, extracts response codes/errors,
+    and non-blockingly dispatches a TelemetryEvent to the Errivanta Monitoring Platform.
+    """
+
+    def __init__(
+        self,
+        app,
+        service_name: str,
+        client: ErrivantaClient,
+        skip_paths: Optional[List[str]] = None,
+    ):
+        super().__init__(app)
+        self.service_name = service_name
+        self.client = client
+        self.skip_paths = skip_paths or ["/docs", "/openapi.json", "/health", "/favicon.ico"]
+
+    async def dispatch(self, request: Request, call_next) -> Response:
+        # Check if route is in skip_paths
+        path = request.url.path
+        if any(path.startswith(skipped) for skipped in self.skip_paths):
+            return await call_next(request)
+
+        start_time = time.perf_counter()
+        status_code = 500
+        error_message = None
+
+        try:
+            response = await call_next(request)
+            status_code = response.status_code
+            return response
+        except Exception as exc:
+            error_message = str(exc)
+            raise exc
+        finally:
+            latency_ms = (time.perf_counter() - start_time) * 1000.0
+
+            event = TelemetryEvent(
+                service_name=self.service_name,
+                endpoint=path,
+                http_method=request.method,
+                status_code=status_code,
+                latency_ms=round(latency_ms, 2),
+                timestamp=datetime.now(timezone.utc),
+                error_message=error_message,
+            )
+
+            # Fire-and-forget asynchronous dispatch
+            asyncio.create_task(self._safe_dispatch(event))
+
+    async def _safe_dispatch(self, event: TelemetryEvent) -> None:
+        """
+        Background dispatch task with error catching to ensure total isolation from customer requests.
+        """
+        try:
+            await self.client.send_event_async(event)
+        except Exception as exc:
+            logger.debug(f"[Errivanta] Non-blocking telemetry background dispatch error: {exc}")
+
+
+# Backward compatibility alias
+ServiceWatchMiddleware = ErrivantaMiddleware

errivanta-0.2.0/errivanta/models.py

@@ -0,0 +1,17 @@
+from datetime import datetime, timezone
+from typing import Dict, Optional, Any
+from pydantic import BaseModel, Field
+
+
+class TelemetryEvent(BaseModel):
+    """
+    Schema for telemetry event payload dispatched by Errivanta SDK.
+    """
+    service_name: str
+    endpoint: str
+    http_method: str
+    status_code: int
+    latency_ms: float
+    timestamp: datetime = Field(default_factory=lambda: datetime.now(timezone.utc))
+    error_message: Optional[str] = None
+    extra_metadata: Dict[str, Any] = Field(default_factory=dict)

errivanta-0.2.0/errivanta.egg-info/PKG-INFO

@@ -0,0 +1,17 @@
+Metadata-Version: 2.4
+Name: errivanta
+Version: 0.2.0
+Summary: Official Python SDK & FastAPI Middleware for Errivanta APM & Observability Platform
+Home-page: https://github.com/codesbyaditya/errivanta
+Author: Errivanta Team
+Author-email: errivanta@gmail.com
+Requires-Python: >=3.9
+Requires-Dist: httpx>=0.27.0
+Requires-Dist: pydantic>=2.0.0
+Requires-Dist: starlette>=0.36.0
+Dynamic: author
+Dynamic: author-email
+Dynamic: home-page
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary

errivanta-0.2.0/errivanta.egg-info/SOURCES.txt

@@ -0,0 +1,12 @@
+README.md
+setup.py
+errivanta/__init__.py
+errivanta/client.py
+errivanta/middleware.py
+errivanta/models.py
+errivanta.egg-info/PKG-INFO
+errivanta.egg-info/SOURCES.txt
+errivanta.egg-info/dependency_links.txt
+errivanta.egg-info/requires.txt
+errivanta.egg-info/top_level.txt
+tests/test_sdk.py

errivanta-0.2.0/errivanta.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

errivanta-0.2.0/errivanta.egg-info/requires.txt

@@ -0,0 +1,3 @@
+httpx>=0.27.0
+pydantic>=2.0.0
+starlette>=0.36.0

errivanta-0.2.0/errivanta.egg-info/top_level.txt

@@ -0,0 +1 @@
+errivanta

errivanta-0.2.0/setup.cfg

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

errivanta-0.2.0/setup.py

@@ -0,0 +1,17 @@
+from setuptools import setup, find_packages
+
+setup(
+    name="errivanta",
+    version="0.2.0",
+    description="Official Python SDK & FastAPI Middleware for Errivanta APM & Observability Platform",
+    author="Errivanta Team",
+    author_email="errivanta@gmail.com",
+    url="https://github.com/codesbyaditya/errivanta",
+    packages=find_packages(),
+    install_requires=[
+        "httpx>=0.27.0",
+        "pydantic>=2.0.0",
+        "starlette>=0.36.0",
+    ],
+    python_requires=">=3.9",
+)

errivanta-0.2.0/tests/test_sdk.py

@@ -0,0 +1,80 @@
+import pytest
+from fastapi import FastAPI
+from fastapi.testclient import TestClient
+from errivanta import Errivanta, ServiceWatch
+from errivanta.client import ErrivantaClient
+from errivanta.models import TelemetryEvent
+
+
+def test_telemetry_event_schema():
+    event = TelemetryEvent(
+        service_name="test-service",
+        endpoint="/api/v1/test",
+        http_method="GET",
+        status_code=200,
+        latency_ms=12.5,
+    )
+    assert event.service_name == "test-service"
+    assert event.status_code == 200
+    assert event.latency_ms == 12.5
+    assert event.error_message is None
+
+
+def test_errivanta_initialization():
+    monitor = Errivanta(
+        service_name="payment-service",
+        api_key="test_key_123",
+        monitoring_url="http://localhost:8001",
+        timeout=1.5,
+    )
+    assert monitor.service_name == "payment-service"
+    assert monitor.api_key == "test_key_123"
+    assert monitor.monitoring_url == "http://localhost:8001"
+    assert isinstance(monitor.client, ErrivantaClient)
+
+
+def test_backward_compatibility_alias():
+    monitor = ServiceWatch(
+        service_name="order-service",
+        api_key="test_key_456",
+        monitoring_url="http://localhost:8001",
+    )
+    assert monitor.service_name == "order-service"
+    assert isinstance(monitor, Errivanta)
+
+
+def test_sdk_middleware_interception():
+    app = FastAPI()
+    monitor = Errivanta(
+        service_name="test-service",
+        api_key="test_key",
+        monitoring_url="http://localhost:8001",
+    )
+    monitor.init_app(app)
+
+    @app.get("/items")
+    def get_items():
+        return {"items": [1, 2, 3]}
+
+    client = TestClient(app)
+    response = client.get("/items")
+    assert response.status_code == 200
+    assert response.json() == {"items": [1, 2, 3]}
+
+
+def test_sdk_error_resilience():
+    # Verify that failed telemetry delivery swallows exceptions and returns False
+    client = ErrivantaClient(
+        api_key="test_key",
+        monitoring_url="http://invalid-host-unreachable.example.com",
+        timeout_seconds=0.1,
+    )
+    event = TelemetryEvent(
+        service_name="test-service",
+        endpoint="/error",
+        http_method="GET",
+        status_code=500,
+        latency_ms=50.0,
+    )
+    result = client.send_event_sync(event)
+    assert result is False