pingoni 0.1.0__py3-none-any.whl

pingoni/__init__.py

@@ -0,0 +1,250 @@
+"""
+Pingoni — Drop-in API monitoring for Flask and FastAPI.
+
+Usage with Flask:
+    from flask import Flask
+    from pingoni import init_flask
+    
+    app = Flask(__name__)
+    init_flask(app, api_key="your_api_key")
+
+Usage with FastAPI:
+    from fastapi import FastAPI
+    from pingoni import init_fastapi
+    
+    app = FastAPI()
+    init_fastapi(app, api_key="your_api_key")
+"""
+
+import json
+import time
+import threading
+import traceback
+from urllib.request import Request, urlopen
+from urllib.error import URLError
+
+__version__ = "0.1.0"
+
+PINGONI_INGEST_URL = "https://apiwatch-production-3f19.up.railway.app/ingest"
+PINGONI_LLM_URL = "https://apiwatch-production-3f19.up.railway.app/api/llm-events"
+
+SENSITIVE_HEADERS = {
+    "authorization", "cookie", "set-cookie", "x-api-key",
+    "x-auth-token", "proxy-authorization"
+}
+
+
+def _build_safe_headers(headers):
+    """Strip sensitive headers, truncate long values."""
+    safe = {}
+    try:
+        for key, value in dict(headers or {}).items():
+            lower = str(key).lower()
+            if lower in SENSITIVE_HEADERS:
+                safe[key] = "[REDACTED]"
+            else:
+                v = str(value)
+                safe[key] = v[:500] + "..." if len(v) > 500 else v
+    except Exception:
+        pass
+    return safe
+
+
+def _send_log(api_key, payload):
+    """Send a log to Pingoni in a background thread. Never blocks or raises."""
+    def _do_send():
+        try:
+            clean = {k: v for k, v in payload.items() if v is not None}
+            data = json.dumps(clean).encode("utf-8")
+            req = Request(
+                PINGONI_INGEST_URL,
+                data=data,
+                headers={
+                    "Content-Type": "application/json",
+                    "x-api-key": api_key,
+                },
+                method="POST",
+            )
+            urlopen(req, timeout=5).read()
+        except Exception:
+            pass  # never crash the user's app
+    
+    t = threading.Thread(target=_do_send, daemon=False)
+    t.start()
+
+
+def init_flask(app, api_key):
+    """
+    Add Pingoni monitoring to a Flask app.
+    
+    Args:
+        app: The Flask application instance
+        api_key: Your Pingoni project API key
+    """
+    if not api_key:
+        print("[Pingoni] No API key provided. Monitoring disabled.")
+        return
+    
+    from flask import request, g
+    
+    @app.before_request
+    def _pingoni_before():
+        g._pingoni_start = time.time()
+    
+    @app.after_request
+    def _pingoni_after(response):
+        try:
+            if getattr(g, "_pingoni_sent", False):
+                return response
+            duration = int((time.time() - g._pingoni_start) * 1000)
+            error_message = None
+            if response.status_code >= 500:
+                error_message = f"Server error ({response.status_code})"
+            elif response.status_code >= 400:
+                error_message = f"Client error ({response.status_code})"
+            
+            _send_log(api_key, {
+                "method": request.method,
+                "endpoint": request.path,
+                "status_code": response.status_code,
+                "response_time": duration,
+                "error_message": error_message,
+                "headers": _build_safe_headers(request.headers),
+                "stack_trace": None,
+            })
+        except Exception:
+            pass
+        return response
+    
+    @app.errorhandler(Exception)
+    def _pingoni_error(err):
+        try:
+            g._pingoni_sent = True
+            duration = int((time.time() - getattr(g, '_pingoni_start', time.time())) * 1000)
+            status = getattr(err, 'code', 500) or 500
+            
+            _send_log(api_key, {
+                "method": request.method,
+                "endpoint": request.path,
+                "status_code": status,
+                "response_time": duration,
+                "error_message": str(err) or "Internal Server Error",
+                "headers": _build_safe_headers(request.headers),
+                "stack_trace": traceback.format_exc(),
+            })
+        except Exception:
+            pass
+        
+        from flask import jsonify
+        return jsonify({"error": str(err) or "Internal Server Error"}), getattr(err, 'code', 500) or 500
+
+
+def init_fastapi(app, api_key):
+    """
+    Add Pingoni monitoring to a FastAPI app.
+    
+    Args:
+        app: The FastAPI application instance
+        api_key: Your Pingoni project API key
+    """
+    if not api_key:
+        print("[Pingoni] No API key provided. Monitoring disabled.")
+        return
+    
+    from starlette.middleware.base import BaseHTTPMiddleware
+    from starlette.responses import JSONResponse
+    
+    class PingoniMiddleware(BaseHTTPMiddleware):
+        async def dispatch(self, request, call_next):
+            start = time.time()
+            try:
+                response = await call_next(request)
+                duration = int((time.time() - start) * 1000)
+                error_message = None
+                if response.status_code >= 500:
+                    error_message = f"Server error ({response.status_code})"
+                elif response.status_code >= 400:
+                    error_message = f"Client error ({response.status_code})"
+                
+                _send_log(api_key, {
+                    "method": request.method,
+                    "endpoint": str(request.url.path),
+                    "status_code": response.status_code,
+                    "response_time": duration,
+                    "error_message": error_message,
+                    "headers": _build_safe_headers(request.headers),
+                    "stack_trace": None,
+                })
+                return response
+            except Exception as err:
+                duration = int((time.time() - start) * 1000)
+                _send_log(api_key, {
+                    "method": request.method,
+                    "endpoint": str(request.url.path),
+                    "status_code": 500,
+                    "response_time": duration,
+                    "error_message": str(err) or "Internal Server Error",
+                    "headers": _build_safe_headers(request.headers),
+                    "stack_trace": traceback.format_exc(),
+                })
+                return JSONResponse(
+                    status_code=500,
+                    content={"error": str(err) or "Internal Server Error"}
+                )
+    
+    app.add_middleware(PingoniMiddleware)
+
+
+def track_llm(provider, model, usage, user_id=None, feature=None, metadata=None, api_key=None):
+    """
+    Track an LLM API call for cost monitoring.
+    
+    Args:
+        provider: LLM provider name (e.g., "openai", "anthropic")
+        model: Model name (e.g., "gpt-4o-mini")
+        usage: Usage dict with prompt_tokens, completion_tokens, total_tokens
+        user_id: Optional user identifier for per-user cost attribution
+        feature: Optional feature name (e.g., "summarization")
+        metadata: Optional dict of additional metadata
+        api_key: Pingoni API key (or set PINGONI_API_KEY env var)
+    """
+    import os
+    if api_key is None:
+        api_key = os.environ.get("PINGONI_API_KEY")
+    
+    if not api_key:
+        print("[Pingoni] No API key for track_llm. Pass api_key= or set PINGONI_API_KEY env var.")
+        return
+    
+    if not provider or not model or not usage:
+        print("[Pingoni] track_llm requires provider, model, and usage.")
+        return
+    
+    def _do_send():
+        try:
+            payload = json.dumps({
+                "provider": provider,
+                "model": model,
+                "usage": usage,
+                "user_id": user_id,
+                "feature": feature,
+                "metadata": metadata,
+            }).encode("utf-8")
+            req = Request(
+                PINGONI_LLM_URL,
+                data=payload,
+                headers={
+                    "Content-Type": "application/json",
+                    "x-api-key": api_key,
+                },
+                method="POST",
+            )
+            urlopen(req, timeout=5).read()
+        except Exception:
+            pass
+    
+    threading.Thread(target=_do_send, daemon=True).start()
+
+
+# Aliases for clarity
+trackLLM = track_llm

pingoni-0.1.0.dist-info/METADATA

@@ -0,0 +1,22 @@
+Metadata-Version: 2.4
+Name: pingoni
+Version: 0.1.0
+Summary: Drop-in API monitoring for Flask and FastAPI
+Author-email: Ayomide <afolaluayomide5@gmail.com>
+License: MIT
+Project-URL: Homepage, https://pingoni.com
+Project-URL: Repository, https://github.com/Ayomide780/pingoni-python
+Keywords: monitoring,flask,fastapi,api,observability
+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
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Framework :: Flask
+Classifier: Framework :: FastAPI
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: requests>=2.25.0

pingoni-0.1.0.dist-info/RECORD

@@ -0,0 +1,5 @@
+pingoni/__init__.py,sha256=bR91_7pasCP6A8oWb618nHrU6ESw2KGegOXqLXWso_I,8529
+pingoni-0.1.0.dist-info/METADATA,sha256=qNYhx70QFz9b95QhxXoQOZ0Tim8a_u2rNmF4EGwEnus,914
+pingoni-0.1.0.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
+pingoni-0.1.0.dist-info/top_level.txt,sha256=lOlWbyjmjPX3TgqWbpvfmW9iOKSjHcAYB9jAiMd1gZQ,8
+pingoni-0.1.0.dist-info/RECORD,,

pingoni-0.1.0.dist-info/WHEEL

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

pingoni-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+pingoni