aeonic-agentguard-sdk-python 0.1.0__py3-none-any.whl

aeonic/core/sender.py

@@ -0,0 +1,234 @@
+import json
+import logging
+import os
+import threading
+import urllib.request
+from collections import deque
+from typing import Any, Dict, Optional
+
+logger = logging.getLogger("aeonic")
+
+# Try to load .env file if python-dotenv is available (optional dependency)
+try:
+    from dotenv import load_dotenv  # type: ignore
+
+    # Load .env file from current working directory or project root
+    load_dotenv()
+except ImportError:
+    # python-dotenv not installed, skip .env loading
+    pass
+
+# Global state matching TS implementation
+queue: deque = deque()
+sending = False
+sending_lock = threading.Lock()
+
+
+def _get_endpoint() -> str:
+    """
+    Get the Aeonic endpoint from environment variable.
+    Reads AEONIC_ENDPOINT, with fallback to production endpoint.
+    This is called lazily to ensure environment variables are loaded.
+    """
+    return os.environ.get("AEONIC_ENDPOINT", "http://45.79.111.106:3291")
+
+
+def detect_origin() -> Optional[str]:
+    """
+    Detect the origin URL from environment variables
+    Checks ORIGIN, BASE_URL, or constructs from HOST/HOSTNAME and PORT
+    """
+    # Check for explicit origin/base URL
+    if os.environ.get("ORIGIN"):
+        return os.environ["ORIGIN"]
+    if os.environ.get("BASE_URL"):
+        return os.environ["BASE_URL"]
+
+    # Construct from HOST/HOSTNAME and PORT
+    host = os.environ.get("HOST") or os.environ.get("HOSTNAME") or "localhost"
+    port = os.environ.get("PORT")
+
+    if port:
+        # Determine protocol (default to http, use https if port is 443 or HTTPS env is set)
+        is_https = os.environ.get("HTTPS") == "true" or port == "443"
+        protocol = "https" if is_https else "http"
+        return f"{protocol}://{host}:{port}"
+
+    # If no port, return just the host (might be a domain like api.abcd.com)
+    if host != "localhost":
+        is_https = os.environ.get("HTTPS") == "true"
+        protocol = "https" if is_https else "http"
+        return f"{protocol}://{host}"
+
+    return None
+
+
+def _is_2xx(status_code: int) -> bool:
+    """Return True if status_code is in the 2xx range."""
+    return 200 <= status_code < 300
+
+
+def enqueue(payload: Dict[str, Any]) -> None:
+    """Add payload to queue and trigger processing (for 2xx samples → /sdk/agent-samples)."""
+    queue.append(payload)
+    _process_queue()
+
+
+def emit_error_sample(payload: Dict[str, Any]) -> None:
+    """
+    Emit a single error sample (non-2xx response) to /sdk/agent-error-samples in real time.
+    Does not buffer; sends immediately in a background thread so the request is not blocked.
+    """
+
+    def _send() -> None:
+        try:
+            origin = detect_origin()
+            headers = {"Content-Type": "application/json"}
+            if origin:
+                headers["origin"] = origin
+                headers["referer"] = origin
+            url = f"{_get_endpoint()}/sdk/agent-error-samples"
+            data = json.dumps(payload).encode("utf-8")
+            req = urllib.request.Request(url, data=data, headers=headers, method="POST")
+            with urllib.request.urlopen(req, timeout=100) as response:
+                response_data = json.loads(response.read())
+                if response_data.get("success"):
+                    if os.environ.get("AEONIC_DEBUG"):
+                        print("[Aeonic] Agent error sample emitted successfully")
+                else:
+                    if os.environ.get("AEONIC_DEBUG"):
+                        print(
+                            f"[Aeonic] Failed to emit agent error sample: {response_data.get('message')}"
+                        )
+        except Exception as err:
+            if os.environ.get("AEONIC_DEBUG"):
+                print(f"[Aeonic] Failed to emit agent error sample: {err}")
+
+    t = threading.Thread(target=_send)
+    t.daemon = True
+    t.start()
+
+
+def _process_queue() -> None:
+    """
+    Trigger the background processing loop.
+    Mimics the recursive/async processQueue in TS.
+    """
+    global sending
+
+    # Check if already sending or queue empty
+    # We use a lock to ensure thread-safety of the 'sending' flag check/set sequence
+    # if we were strictly launching threads, but here we just check if we need to start a worker.
+    if sending or not queue:
+        return
+
+    # Start a background thread to process the queue
+    # This prevents blocking the main thread (like async usually implies)
+    t = threading.Thread(target=_process_queue_worker)
+    t.daemon = True
+    t.start()
+
+
+def _process_queue_worker() -> None:
+    """Background worker to drain the queue."""
+    global sending
+
+    # helper to acquire lock and set sending
+    with sending_lock:
+        if sending:
+            return
+        sending = True
+
+    try:
+        while True:
+            # Get next payload
+            try:
+                # TS: const payload = queue.shift();
+                payload = queue.popleft()
+            except IndexError:
+                # Queue is empty
+                break
+
+            try:
+                # Detect origin and referer from environment
+                origin = detect_origin()
+                headers = {"Content-Type": "application/json"}
+
+                if origin:
+                    headers["origin"] = origin
+                    headers["referer"] = origin
+
+                url = f"{_get_endpoint()}/sdk/agent-samples"
+                data = json.dumps(payload).encode("utf-8")
+                req = urllib.request.Request(url, data=data, headers=headers, method="POST")
+
+                # TS: await axios.post(...)
+                # 10s timeout to avoid hanging indefinitely
+                with urllib.request.urlopen(req, timeout=100) as response:
+                    response_data = json.loads(response.read())
+                    if response_data.get("success"):
+                        print("[Aeonic] Agent samples emitted successfully")
+                    else:
+                        print(
+                            f"[Aeonic] Failed to emit agent samples: {response_data.get('message')}"
+                        )
+
+            except Exception as err:
+                if os.environ.get("AEONIC_DEBUG"):
+                    # TS: console.error(...)
+                    print(f"[Aeonic] Failed to emit agent samples: {err}")
+
+                # retry later (simple strategy for v1)
+                # TS: queue.push(payload!)
+                queue.append(payload)
+                # Prevent tight loop in case of persistent error?
+                # TS implementation doesn't sleep, but in Python thread it might consume CPU.
+                # Use a small sleep? User asked for "behhave same... nothing else".
+                # I will trust the "same" requirement strictly.
+
+    finally:
+        with sending_lock:
+            sending = False
+
+        # Determine if we need to restart (if items added while exiting)
+        if queue:
+            _process_queue()
+
+
+def emit_agent_inventory(payload: Dict[str, Any]) -> bool:
+    """
+    Emit agent inventory to the backend
+    This is sent ONCE per process lifecycle
+    Does NOT block startup and does NOT throw on failure
+    """
+    try:
+        # Detect origin and referer from environment
+        origin = detect_origin()
+        headers = {"Content-Type": "application/json"}
+
+        if origin:
+            headers["origin"] = origin
+            headers["referer"] = origin
+
+        url = f"{_get_endpoint()}/sdk/agent-inventory"
+        data = json.dumps(payload).encode("utf-8")
+
+        print(f"[Aeonic] Emitting agent inventory to {url}")
+        req = urllib.request.Request(url, data=data, headers=headers, method="POST")
+
+        with urllib.request.urlopen(req, timeout=100) as response:
+            response_data = json.loads(response.read())
+            if response_data.get("success"):
+                print("[Aeonic] Agent inventory emitted successfully")
+                return True
+            else:
+                print(f"[Aeonic] Failed to emit agent inventory: {response_data.get('message')}")
+                return False
+
+    except Exception as err:
+        # Silently fail - do NOT break startup
+        # Log for debugging purposes only
+        if os.environ.get("AEONIC_DEBUG"):
+            print(f"[Aeonic] Failed to emit agent inventory: {err}")
+
+        raise err

aeonic/core/types.py

@@ -0,0 +1,51 @@
+from typing import Any, Dict, List, Optional, TypedDict
+
+
+class AgentContext(TypedDict, total=False):
+    name: str
+    type: str
+    model: List[str]
+    source: str
+
+
+class RouteContext(TypedDict):
+    path: str
+    method: str
+
+
+class Sample(TypedDict, total=False):
+    req: Optional[Dict[str, Any]]
+    res: Optional[Dict[str, Any]]
+    timestamp: int
+    status_code: Optional[int]  # HTTP status; included for error samples, optional for 2xx
+
+
+class FlushPayload(TypedDict):
+    api_key: str
+    service_name: Optional[str]
+    agent: AgentContext
+    route: RouteContext
+    samples: List[Sample]
+
+
+class AgentDescriptor(TypedDict, total=False):
+    """Describes a registered agent with metadata."""
+
+    name: str
+    type: Optional[str]
+    model: Optional[List[str]]
+    route_path: Optional[str]
+    http_method: Optional[str]
+    framework: str
+    service_name: Optional[str]
+    declared_at: float
+
+
+class InventoryPayload(TypedDict):
+    """Payload for agent inventory emission."""
+
+    event: str
+    api_key: str
+    service_name: Optional[str]
+    framework: str
+    agents: List[AgentDescriptor]

aeonic/utils/__init__.py

@@ -0,0 +1 @@
+"""Shared utility helpers for the Aeonic SDK."""

aeonic/utils/safe_serialize.py

@@ -0,0 +1,22 @@
+# aeonic/utils/safe_serialize.py
+
+from typing import Any
+
+
+def safe_serialize(value: Any) -> Any:
+    try:
+        if value is None:
+            return None
+
+        if isinstance(value, (str, int, float, bool)):
+            return value
+
+        if isinstance(value, dict):
+            return {k: safe_serialize(v) for k, v in value.items()}
+
+        if isinstance(value, list):
+            return [safe_serialize(v) for v in value]
+
+        return str(value)
+    except Exception:
+        return None