errivanta 0.2.0__py3-none-any.whl

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/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/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/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.dist-info/METADATA

@@ -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.dist-info/RECORD

@@ -0,0 +1,8 @@
+errivanta/__init__.py,sha256=CE1HKYLQM4jrcKEtjVqOXBuu3rg6poadmtX8iEO0wKI,1810
+errivanta/client.py,sha256=YktL7ADqDZQgwOC6BVwk_VvGWAhNMyN63cVllH5kM4M,2946
+errivanta/middleware.py,sha256=msFXwqbbN0ItO156SBNMRfXEURCNWnjiRk1WKf6zNHE,2651
+errivanta/models.py,sha256=acVwI6llJdLuwXWMNzU52TqKbWFHmBKYXl8uU8JNL8Y,529
+errivanta-0.2.0.dist-info/METADATA,sha256=JK02fSnRMGA-PRkiKy-nJKo7rfCc78RQlbvlNFfubH0,512
+errivanta-0.2.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+errivanta-0.2.0.dist-info/top_level.txt,sha256=kPOqd27S_X26o0X2y7ajb0NKUYITgicazctKVCcWvY4,10
+errivanta-0.2.0.dist-info/RECORD,,

errivanta-0.2.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

errivanta-0.2.0.dist-info/top_level.txt

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