logsentinel 0.1.0__tar.gz

logsentinel-0.1.0/.gitignore

@@ -0,0 +1,11 @@
+# Python-generated files
+__pycache__/
+*.py[oc]
+build/
+dist/
+wheels/
+*.egg-info
+.vscode/
+# Virtual environments
+.venv
+.env

logsentinel-0.1.0/.http

@@ -0,0 +1,12 @@
+### Simple POST to FastAPI /hello
+POST http://127.0.0.1:8002/hello
+Content-Type: application/json
+
+{
+  "message": "Hello world",
+  "username": "Jeckonia"
+}
+
+###
+
+GET http://localhost:8002/error

logsentinel-0.1.0/.python-version

@@ -0,0 +1 @@
+3.14

logsentinel-0.1.0/PKG-INFO

@@ -0,0 +1,57 @@
+Metadata-Version: 2.4
+Name: logsentinel
+Version: 0.1.0
+Summary: AI-powered log monitoring SDK for Python applications
+Project-URL: Homepage, https://github.com/inctifra/logsentinel
+Project-URL: Documentation, https://pypi.org/project/logsentinel
+Project-URL: Source, https://github.com/inctifra/logsentinel
+Author-email: Jeckonia Kwasa <inctifra@gmail.com>
+License: MIT
+Requires-Python: >=3.9
+Requires-Dist: aiohttp>=3.13.2
+Requires-Dist: backoff>=2.2.1
+Requires-Dist: django-environ>=0.12.0
+Requires-Dist: fastapi[all]>=0.121.1
+Requires-Dist: httpx>=0.28.1
+Requires-Dist: requests>=2.32.3
+Requires-Dist: rich>=14.2.0
+Description-Content-Type: text/markdown
+
+# LogSentinel Python SDK
+
+LogSentinel is a lightweight SDK for monitoring and analyzing logs in Python applications. It automatically captures request and response data, builds detailed metadata, and sends them to the LogSentinel AI platform for analysis.
+
+## Installation
+
+```bash
+pip install logsentinel
+```
+
+## Setup
+
+1. Go to the [LogSentinel Dashboard](https://sentinel.ivps.cloud) and create an API key.
+2. Add it to your environment variables:
+
+```bash
+export LOGSENTINEL_API_KEY="your_api_key_here"
+```
+
+## Example (FastAPI)
+
+```python
+from fastapi import FastAPI
+from logosentinel import LogSentinelASGIMiddleware
+
+app = FastAPI()
+app.add_middleware(LogSentinelASGIMiddleware)
+
+@app.post("/hello")
+async def hello(data: dict):
+    return {"message": "Hello, world!", "received": data}
+```
+
+Logs will automatically be captured and sent to your LogSentinel dashboard for AI analysis.
+
+## License
+
+MIT License

logsentinel-0.1.0/README.md

@@ -0,0 +1,38 @@
+# LogSentinel Python SDK
+
+LogSentinel is a lightweight SDK for monitoring and analyzing logs in Python applications. It automatically captures request and response data, builds detailed metadata, and sends them to the LogSentinel AI platform for analysis.
+
+## Installation
+
+```bash
+pip install logsentinel
+```
+
+## Setup
+
+1. Go to the [LogSentinel Dashboard](https://sentinel.ivps.cloud) and create an API key.
+2. Add it to your environment variables:
+
+```bash
+export LOGSENTINEL_API_KEY="your_api_key_here"
+```
+
+## Example (FastAPI)
+
+```python
+from fastapi import FastAPI
+from logosentinel import LogSentinelASGIMiddleware
+
+app = FastAPI()
+app.add_middleware(LogSentinelASGIMiddleware)
+
+@app.post("/hello")
+async def hello(data: dict):
+    return {"message": "Hello, world!", "received": data}
+```
+
+Logs will automatically be captured and sent to your LogSentinel dashboard for AI analysis.
+
+## License
+
+MIT License

logsentinel-0.1.0/examples/fastapi.py

@@ -0,0 +1,25 @@
+
+from fastapi import FastAPI, HTTPException, responses
+from logosentinel import LogSentinelASGIMiddleware
+
+
+app = FastAPI()
+app.add_middleware(
+    LogSentinelASGIMiddleware,
+   # api_key=API_KEY,
+    send_remote=True
+)
+
+@app.post("/hello")
+async def hello_post(payload: dict):
+    return responses.JSONResponse(content={"detail": "Invalid user credentials"}, status_code=401)
+
+@app.get("/error")
+async def error():
+    raise HTTPException(status_code=500, detail="Test error")
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(app, host="127.0.0.1", port=8002)
+
+

logsentinel-0.1.0/logosentinel/__init__.py

@@ -0,0 +1,17 @@
+from .config.prod import DEFAULT_BASE_URL, DEFAULT_API_KEY
+from .client.sync import LogSentinelClient
+from .client.a_sync import AsyncLogSentinelClient
+from .middleware import LogSentinelASGIMiddleware, LogSentinelWSGIMiddleware
+from .handler import LogSentinelHandler
+from .logger import SentinelLogger
+
+__all__ = [
+    "LogSentinelClient",
+    "AsyncLogSentinelClient",
+    "LogSentinelASGIMiddleware",
+    "LogSentinelWSGIMiddleware",
+    "LogSentinelHandler",
+    "SentinelLogger",
+    "DEFAULT_BASE_URL",
+    "DEFAULT_API_KEY"
+]

logsentinel-0.1.0/logosentinel/client/a_sync.py

@@ -0,0 +1,53 @@
+import asyncio
+import httpx
+import logging
+from typing import Dict, Optional
+from logosentinel.config.prod import DEFAULT_API_KEY, DEFAULT_BASE_URL
+from logosentinel.libs.utils import utc_now_iso, safe_str
+
+logger = logging.getLogger("logsentinel.async_client")
+
+class AsyncLogSentinelClient:
+    """
+    Async client that immediately sends logs to LogSentinel backend using httpx.
+    """
+
+    def __init__(self, api_key: str = DEFAULT_API_KEY, base_url: str = DEFAULT_BASE_URL):
+        if not api_key:
+            raise ValueError("api_key is required")
+        self.api_key = api_key
+        self.base_url = base_url.rstrip("/")
+        self._client: Optional[httpx.AsyncClient] = None
+
+    async def _get_client(self):
+        if self._client is None:
+            self._client = httpx.AsyncClient(
+                headers={
+                    "Authorization": f"Bearer {self.api_key}",
+                    "Content-Type": "application/json",
+                    "User-Agent": "logsentinel-python-sdk/1.0",
+                },
+                timeout=5.0
+            )
+        return self._client
+
+    async def send(self, message: str, level: str = "INFO", metadata: Optional[Dict] = None):
+        payload = {
+            "timestamp": utc_now_iso(),
+            "message": safe_str(message),
+            "level": level.upper(),
+            "metadata": metadata or {},
+        }
+        try:
+            client = await self._get_client()
+            response = await client.post(f"{self.base_url}/api/sdk/logs", json=payload)
+            response.raise_for_status()
+            return response.json()
+        except httpx.HTTPError as e:
+            logger.error("Failed to send log to LogSentinel: %s", e)
+            return None
+
+    async def close(self):
+        if self._client:
+            await self._client.aclose()
+            self._client = None

logsentinel-0.1.0/logosentinel/client/sync.py

@@ -0,0 +1,43 @@
+import requests
+import logging
+from typing import Dict, Optional
+from logosentinel.config.prod import DEFAULT_API_KEY, DEFAULT_BASE_URL
+from logosentinel.libs.utils import utc_now_iso, safe_str
+
+logger = logging.getLogger("logsentinel.client.sync")
+
+class LogSentinelClient:
+    """
+    Synchronous client that immediately sends logs to LogSentinel backend.
+    """
+
+    def __init__(self, api_key: str = DEFAULT_API_KEY, base_url: str = DEFAULT_BASE_URL):
+        if not api_key:
+            raise ValueError("api_key is required")
+        self.api_key = api_key
+        self.base_url = base_url.rstrip("/")
+        self.session = requests.Session()
+        self.session.headers.update({
+            "Authorization": f"Bearer {self.api_key}",
+            "Content-Type": "application/json",
+            "User-Agent": "logsentinel-python-sdk/1.0",
+        })
+
+    def send(self, message: str, level: str = "INFO", metadata: Optional[Dict] = None):
+        """
+        Immediately send a log to the backend.
+        """
+        payload = {
+            "timestamp": utc_now_iso(),
+            "message": safe_str(message),
+            "level": level.upper(),
+            "metadata": metadata or {},
+        }
+        try:
+            url = f"{self.base_url}/logs"
+            response = self.session.post(url, json=payload, timeout=5)
+            response.raise_for_status()
+            return response.json()  # optional, if backend returns JSON
+        except requests.RequestException as e:
+            logger.error("Failed to send log to LogSentinel: %s", e)
+            return None

logsentinel-0.1.0/logosentinel/config/base.py

@@ -0,0 +1,9 @@
+from pathlib import Path
+import environ
+
+BASE_DIR = Path(__file__).resolve().parent.parent.parent
+
+
+env = environ.Env(DEBUG=True, LOG_LEVEL="warn")
+
+env.read_env(str(BASE_DIR / ".env"))

logsentinel-0.1.0/logosentinel/config/prod.py

@@ -0,0 +1,10 @@
+from .base import env
+
+
+DEFAULT_BASE_URL = env.str("LOG_SENTINEL_BASE_URL", default="http://localhost:8000")
+DEFAULT_API_KEY = env.str("LOG_SENTINEL_API_KEY")
+DEFAULT_BATCH_SIZE = env.int("LOG_SENTINEL_BATCH_SIZE", default=25)
+DEFAULT_BATCH_INTERVAL = env.float("LOG_SENTINEL_BATCH_INTERVAL", default=3.0)
+DEFAULT_RETRY_ATTEMPTS = env.int("LOG_SENTINEL_RETRY_ATTEMPTS", default=10)
+DEFAULT_MIN_REMOTE_LEVEL = env.str("LOG_SENTINEL_MIN_LEVEL", default="WARN")
+

logsentinel-0.1.0/logosentinel/exceptions.py

@@ -0,0 +1,5 @@
+class LogSentinelError(Exception):
+    pass
+
+class ConfigurationError(LogSentinelError):
+    pass

logsentinel-0.1.0/logosentinel/handler.py

@@ -0,0 +1,30 @@
+import logging
+from logosentinel.client.sync import LogSentinelClient
+
+class LogSentinelHandler(logging.Handler):
+    def __init__(self, api_key: str, level=logging.NOTSET, base_url: str = None, min_remote_level: str = "INFO"):
+        super().__init__(level)
+        self.client = LogSentinelClient(api_key, base_url) if api_key else None
+        self.min_remote_level = min_remote_level
+
+        # map level name to numeric threshold
+        self.level_map = {
+            "DEBUG": 10, "INFO": 20, "SUCCESS": 25,
+            "WARNING": 30, "ERROR": 40, "CRITICAL": 50
+        }
+        self.min_value = self.level_map.get(self.min_remote_level.upper(), 20)
+
+    def emit(self, record: logging.LogRecord):
+        try:
+            level_name = record.levelname
+            level_val = self.level_map.get(level_name, record.levelno)
+            message = self.format(record)
+            metadata = {
+                "logger": record.name,
+                "pathname": record.pathname,
+                "lineno": record.lineno,
+            }
+            if self.client and level_val >= self.min_value:
+                self.client.send(message, level=level_name, metadata=metadata)
+        except Exception:
+            self.handleError(record)

logsentinel-0.1.0/logosentinel/libs/utils.py

@@ -0,0 +1,158 @@
+import time
+import threading
+from typing import Any, Dict
+from datetime import datetime, timezone
+import platform
+import socket
+import os
+import traceback
+import uuid
+
+def utc_now_iso():
+    """
+    Return the time in isoformat
+    
+    Useful for system log timestamp
+    """
+    return datetime.now(timezone.utc).isoformat()
+
+def safe_str(obj) -> str:
+    try:
+        return str(obj)
+    except Exception:
+        return "<unserializable>"
+
+
+def run_in_thread(fn):
+    """Decorator to run a function in a daemon thread."""
+    def wrapper(*args, **kwargs):
+        t = threading.Thread(target=fn, args=args, kwargs=kwargs, daemon=True)
+        t.start()
+        return t
+    return wrapper
+
+
+SENSITIVE_KEYS = [
+    "KEY", "SECRET", "TOKEN", "PASSWORD", "API_KEY", "ACCESS", "PRIVATE"
+]
+
+def mask_sensitive_env(env: dict) -> dict:
+    """Return a copy of env with sensitive values masked."""
+    safe_env = {}
+    for k, v in env.items():
+        if any(s in k.upper() for s in SENSITIVE_KEYS):
+            safe_env[k] = "***REDACTED***"
+        else:
+            safe_env[k] = v
+    return safe_env
+
+
+def build_metadata(scope=None, environ=None, exc=None, start_time=None, request=None, response=None,
+                   request_body=None, response_body=None):
+    """
+    Build rich metadata for logging.
+
+    Args:
+        scope: ASGI scope object.
+        environ: WSGI environ object.
+        exc: Exception object if any.
+        start_time: Request start time for duration calculation.
+        request: Optional DRF/Starlette request object.
+        response: Optional response object for status/body info.
+
+    Returns:
+        dict: enriched metadata for log submission.
+    """
+    duration = int((time.time() - start_time) * 1000) if start_time else None
+    client_ip = "unknown"
+    path = method = ""
+    headers = {}
+    query_params = {}
+    body_length = None
+
+    # ASGI
+    if scope:
+        path = scope.get("path", "")
+        method = scope.get("method", "GET")
+        client = scope.get("client")
+        if client:
+            client_ip = client[0]
+        headers = {k.decode() if isinstance(k, bytes) else k: v.decode() if isinstance(v, bytes) else v
+                   for k, v in scope.get("headers", [])}
+        query_string = scope.get("query_string", b"")
+        query_params = dict([q.split(b"=") for q in query_string.split(b"&") if b"=" in q])
+        query_params = {k.decode(): v.decode() for k, v in query_params.items()}
+
+    # WSGI
+    elif environ:
+        path = environ.get("PATH_INFO", "")
+        method = environ.get("REQUEST_METHOD", "")
+        client_ip = environ.get("REMOTE_ADDR", "unknown")
+        headers = {k[5:].replace("_", "-").title(): v for k, v in environ.items() if k.startswith("HTTP_")}
+        query_params = environ.get("QUERY_STRING", "")
+    
+    # If DRF/Starlette Request object available
+    if request:
+        try:
+            query_params = dict(request.query_params)
+        except Exception:
+            pass
+        try:
+            body_length = len(request.body) if hasattr(request, "body") else None
+        except Exception:
+            body_length = None
+
+    # Response info
+    status_code = None
+    response_length = None
+    if response:
+        status_code = getattr(response, "status_code", None)
+        response_length = len(getattr(response, "content", b"")) if hasattr(response, "content") else None
+
+    # Build final metadata
+    metadata = {
+        "id": str(uuid.uuid4()),
+        "path": path,
+        "method": method,
+        "duration_ms": duration,
+        "client_ip": client_ip,
+        "python_version": platform.python_version(),
+        "os": platform.platform(),
+        "hostname": socket.gethostname(),
+        "pid": os.getpid(),
+        "thread_name": threading.current_thread().name,
+        "timestamp": utc_now_iso(),
+        "headers": headers,
+        "query_params": query_params,
+        "request_body_length": body_length,
+        "response_status": status_code,
+        "response_length": response_length,
+        # "environment":  mask_sensitive_env(dict(os.environ)),  # optional: can filter for secrets
+        "response_body_length": len(response_body) if response_body else None,
+        "request_body": request_body,
+        "response_body": response_body,
+    }
+    metadata["full_url"] = f"{metadata['headers'].get('schema', 'https')}://{metadata['headers'].get('host')}{metadata['path']}"
+
+
+    # Exception info
+    if exc:
+        metadata.update({
+            "exception_type": type(exc).__name__,
+            "exception_message": str(exc),
+            "stack_trace": traceback.format_exc(),
+        })
+
+
+
+
+    # Optional user/project info
+    if request and hasattr(request, "user"):
+        metadata["user"] = getattr(request.user, "username", None)
+        metadata["project"] = getattr(request.user, "name", None)
+
+    return metadata
+
+
+
+

logsentinel-0.1.0/logosentinel/logger.py

@@ -0,0 +1,31 @@
+import logging
+from rich.console import Console
+from logosentinel.client.sync import LogSentinelClient
+
+console = Console()
+
+class SentinelLogger:
+    LEVELS = {"DEBUG":10,"INFO":20,"SUCCESS":25,"WARNING":30,"ERROR":40,"CRITICAL":50}
+    COLOR = {"DEBUG":"magenta","INFO":"cyan","SUCCESS":"green","WARNING":"yellow","ERROR":"red","CRITICAL":"bold red"}
+
+    def __init__(self, api_key: str = None, base_url: str = None, send_remote: bool = True, min_remote_level: str = "INFO"):
+        self.client = LogSentinelClient(api_key, base_url) if send_remote and api_key else None
+        self.send_remote = send_remote and api_key is not None
+        self.min_remote_level = min_remote_level.upper()
+        self.min_remote_value = self.LEVELS.get(self.min_remote_level, 20)
+
+    def _log(self, level: str, msg: str, **kwargs):
+        level = level.upper()
+        console.print(f"[{self.COLOR.get(level,'white')}][{level}][/]: {msg}")
+        if self.send_remote and self.client and self.LEVELS.get(level,20) >= self.min_remote_value:
+            self.client.send(msg, level=level, metadata=kwargs)
+
+    def debug(self,msg,**k): self._log("DEBUG",msg,**k)
+    def info(self,msg,**k): self._log("INFO",msg,**k)
+    def success(self,msg,**k): self._log("SUCCESS",msg,**k)
+    def warning(self,msg,**k): self._log("WARNING",msg,**k)
+    def error(self,msg,**k): self._log("ERROR",msg,**k)
+    def critical(self,msg,**k): self._log("CRITICAL",msg,**k)
+    def exception(self,msg,**k):
+        import traceback
+        self._log("ERROR", f"{msg}\n{traceback.format_exc()}", **k)

logsentinel-0.1.0/logosentinel/middleware.py

@@ -0,0 +1,145 @@
+import time
+import logging
+
+from typing import Optional, Any
+
+from logosentinel.client.a_sync import AsyncLogSentinelClient
+from logosentinel.libs.utils import build_metadata
+from logosentinel.config.prod import DEFAULT_BASE_URL, DEFAULT_API_KEY
+logger = logging.getLogger("logsentinel.middleware")
+
+status = None
+response_body = b""
+metadata = None
+
+# ASGI middleware
+class LogSentinelASGIMiddleware:
+    def __init__(
+        self,
+        app: Optional[Any] =None,
+        api_key: str= DEFAULT_API_KEY,
+        base_url: Optional[str] = DEFAULT_BASE_URL,
+        send_remote: bool = True,
+    ):
+        self.app = app
+        self.client = AsyncLogSentinelClient(api_key, base_url) if send_remote else None
+
+    async def __call__(self, scope, receive, send):
+        if scope.get("type") != "http":
+            await self.app(scope, receive, send)
+            return
+
+        start = time.time()
+        request_body = b""
+        
+        
+        
+
+        # --- Capture the incoming request body ---
+        async def receive_wrapper():
+            nonlocal request_body
+            message = await receive()
+            if message["type"] == "http.request":
+                body_chunk = message.get("body", b"")
+                request_body += body_chunk
+            return message
+
+        # --- Capture response info ---
+        async def send_wrapper(message):
+            nonlocal request_body
+            nonlocal metadata
+            nonlocal start
+            status = ""
+            response_body = b""
+
+            if message["type"] == "http.response.start":
+                status = message.get("status")
+                metadata = build_metadata(
+                    scope=scope,
+                    start_time=start,
+                    request_body=request_body.decode("utf-8", errors="ignore"),
+                )
+                metadata["response_status"] = status
+
+            elif message["type"] == "http.response.body":
+                body_chunk = message.get("body", b"")
+                response_body += body_chunk
+
+                if not message.get("more_body", False):
+                    metadata["response_length"] = len(response_body)
+                    metadata["request_body_length"] = len(request_body)
+
+                    try:
+                        metadata["response_body"] = response_body.decode("utf-8", errors="ignore")
+                    except Exception:
+                        metadata["response_body"] = "<could not decode>"
+
+                    if self.client:
+                        await self.client.send(
+                            f"{metadata['method']} {metadata['path']} - {status}",
+                            level="INFO",
+                            metadata=metadata,
+                        )
+
+            await send(message)
+
+        try:
+            await self.app(scope, receive_wrapper, send_wrapper)
+        except Exception as exc:
+            metadata = build_metadata(
+                scope=scope,
+                exc=exc,
+                start_time=start,
+                request_body=request_body.decode("utf-8", errors="ignore"),
+            )
+            if self.client:
+                await self.client.send(
+                    f"Exception on {metadata['method']} {metadata['path']}",
+                    level="ERROR",
+                    metadata=metadata,
+                )
+            raise
+
+
+# WSGI middleware
+class LogSentinelWSGIMiddleware:
+    def __init__(
+        self,
+        app: Optional[Any] =None,
+        api_key: str = DEFAULT_API_KEY,
+        base_url: Optional[str] = None,
+        send_remote: bool = True,
+    ):
+        self.app = app
+        self.client = AsyncLogSentinelClient(api_key, base_url) if send_remote else None
+
+    def __call__(self, environ, start_response):
+        start_time = time.time()
+
+        def custom_start_response(status, response_headers, exc_info=None):
+            try:
+                status_code = int(status.split(" ", 1)[0])
+            except Exception:
+                status_code = 0
+
+            metadata = build_metadata(environ=environ, start_time=start_time)
+            metadata["status"] = status_code
+            if self.client:
+                self.client.send(
+                    f"{metadata['method']} {metadata['path']} - {status_code}",
+                    level="INFO",
+                    metadata=metadata,
+                )
+            return start_response(status, response_headers, exc_info)
+
+        try:
+            return self.app(environ, custom_start_response)
+        except Exception as exc:
+            metadata = build_metadata(environ=environ, exc=exc, start_time=start_time)
+            if self.client:
+                self.client.send(
+                    f"Exception on {metadata['method']} {metadata['path']}",
+                    level="ERROR",
+                    metadata=metadata,
+                )
+            raise