ulinzilogs 0.1.1__tar.gz

ulinzilogs-0.1.1/PKG-INFO

@@ -0,0 +1,219 @@
+Metadata-Version: 2.4
+Name: ulinzilogs
+Version: 0.1.1
+Summary: Security logging middleware for FastAPI, Flask, and Django
+Author-email: PashyGeek <codyypashy@gmail.com>
+Project-URL: Homepage, https://github.com/PashyGeek/ulinzilogs
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: requests>=2.28.0
+Provides-Extra: fastapi
+Requires-Dist: starlette>=0.20.0; extra == "fastapi"
+Provides-Extra: flask
+Requires-Dist: flask>=2.0.0; extra == "flask"
+Provides-Extra: django
+Requires-Dist: django>=3.2; extra == "django"
+Provides-Extra: all
+Requires-Dist: starlette>=0.20.0; extra == "all"
+Requires-Dist: flask>=2.0.0; extra == "all"
+Requires-Dist: django>=3.2; extra == "all"
+
+# Ulinzilogs 🛡️
+
+> **Lightweight, non‑blocking security logging middleware for Python web apps**
+> Built for developers who want **visibility without performance pain**.
+
+---
+
+## 🌍 What is Ulinzilogs?
+
+**Ulinzilogs** is a security‑focused middleware that silently watches incoming HTTP requests in your Python web application, **redacts sensitive data**, and **ships sanitized logs** to the Ulinzi Security API for **AI‑powered threat analysis**.
+
+Think of it as:
+
+> 🔐 *A security camera for your API — always on, never in the way.*
+
+---
+
+## ✨ Key Features
+
+* 🚀 **Non‑Blocking by Design** — Uses background threads so your request/response cycle stays fast.
+* 🔒 **Automatic Data Redaction** — Sensitive fields are replaced with `[REDACTED]` before leaving your server.
+* 🌐 **Multi‑Framework Support** — Works out of the box with FastAPI, Flask, and Django.
+* 🧹 **Clean & Safe Headers** — Excludes `Authorization` and `Cookie` headers automatically.
+
+---
+
+## 📦 Installation
+
+Install only what your stack needs:
+
+```bash
+# FastAPI / Starlette
+pip install ulinzilogs[fastapi]
+
+# Flask
+pip install ulinzilogs[flask]
+
+# Django
+pip install ulinzilogs[django]
+
+# All frameworks
+pip install ulinzilogs[all]
+```
+
+---
+
+## 🔑 Getting Your Project Key
+
+After installing, run:
+
+```bash
+ulinzi-init
+```
+
+This generates a **unique Project Key** for your app and prints setup instructions.
+
+> ⚠️ **Important:** This key is generated locally on your machine.
+> To activate it, copy the key and register it at **[ulinzilogs.com](https://ulinzilogs.com)**.
+> Once registered, your dashboard will start receiving logs from your app.
+
+---
+
+## ⚙️ Setup & Usage
+
+### 🟢 FastAPI
+
+```python
+from fastapi import FastAPI
+from ulinzilogs import UlinziFastAPIMiddleware
+
+app = FastAPI()
+
+app.add_middleware(
+    UlinziFastAPIMiddleware,
+    api_key="YOUR_ULINZI_KEY"
+)
+
+@app.get("/")
+async def root():
+    return {"message": "Protected by Ulinzi"}
+```
+
+---
+
+### 🔵 Flask
+
+```python
+from flask import Flask
+from ulinzilogs import UlinziFlaskMiddleware
+
+app = Flask(__name__)
+UlinziFlaskMiddleware(app, api_key="YOUR_ULINZI_KEY")
+
+@app.route("/")
+def hello():
+    return "Protected by Ulinzi"
+```
+
+---
+
+### 🟣 Django
+
+In `settings.py`:
+
+```python
+MIDDLEWARE = [
+    # ... other middleware
+    'ulinzilogs.UlinziDjangoMiddleware',
+]
+
+ULINZI_API_KEY = "YOUR_ULINZI_KEY"
+ULINZI_APP_NAME = "MyDjangoApp"   # optional label shown in dashboard
+```
+
+---
+
+## 🧠 How Ulinzilogs Works
+Client Request
+│
+▼
+┌───────────────┐
+│   Middleware  │
+└──────┬────────┘
+│
+▼
+┌────────────────────┐
+│  Redact Sensitive  │
+│  Fields & Headers  │
+└──────┬─────────────┘
+│
+▼   (Background Thread)
+┌────────────────────┐
+│  Send to Ulinzi    │
+│  Security API      │
+└──────┬─────────────┘
+│
+▼
+┌────────────────────┐
+│ AI Threat Analysis │
+│ (SQLi, XSS, etc.)  │
+└────────────────────┘
+
+1. **Intercept** — Captures request metadata (IP, URL, method, body).
+2. **Redact** — Removes secrets before transmission.
+3. **Dispatch** — Sends logs asynchronously in a background thread.
+4. **Analyze** — Central AI scans for malicious patterns.
+
+---
+
+## 🔐 Sensitive Data Protection
+
+The following keys are **automatically redacted**:
+
+| Field | Redacted? |
+|-------|-----------|
+| `password` | ✅ Yes |
+| `secret` | ✅ Yes |
+| `token` | ✅ Yes |
+| `key` | ✅ Yes |
+| `cvv` | ✅ Yes |
+| `api_key` | ✅ Yes |
+
+Example:
+
+```json
+{
+  "email": "user@mail.com",
+  "password": "[REDACTED]"
+}
+```
+
+Your users' secrets **never leave your server in plaintext**.
+
+---
+
+## ⚡ Performance Philosophy
+
+* No request blocking
+* No database writes on your server
+* No logging delays
+
+Ulinzilogs runs **beside** your app — not **inside** its critical path.
+
+---
+
+## 🧩 Package Structure
+ulinzilogs/
+├── init.py
+├── middleware.py
+├── utils.py
+├── cli.py
+├── pyproject.toml
+└── README.md
+
+---
+
+## 📜 License
+
+Copyright (c) 2026 PashyGeek. Licensed under the MIT License — see the LICENSE file for details.

ulinzilogs-0.1.1/README.md

@@ -0,0 +1,199 @@
+# Ulinzilogs 🛡️
+
+> **Lightweight, non‑blocking security logging middleware for Python web apps**
+> Built for developers who want **visibility without performance pain**.
+
+---
+
+## 🌍 What is Ulinzilogs?
+
+**Ulinzilogs** is a security‑focused middleware that silently watches incoming HTTP requests in your Python web application, **redacts sensitive data**, and **ships sanitized logs** to the Ulinzi Security API for **AI‑powered threat analysis**.
+
+Think of it as:
+
+> 🔐 *A security camera for your API — always on, never in the way.*
+
+---
+
+## ✨ Key Features
+
+* 🚀 **Non‑Blocking by Design** — Uses background threads so your request/response cycle stays fast.
+* 🔒 **Automatic Data Redaction** — Sensitive fields are replaced with `[REDACTED]` before leaving your server.
+* 🌐 **Multi‑Framework Support** — Works out of the box with FastAPI, Flask, and Django.
+* 🧹 **Clean & Safe Headers** — Excludes `Authorization` and `Cookie` headers automatically.
+
+---
+
+## 📦 Installation
+
+Install only what your stack needs:
+
+```bash
+# FastAPI / Starlette
+pip install ulinzilogs[fastapi]
+
+# Flask
+pip install ulinzilogs[flask]
+
+# Django
+pip install ulinzilogs[django]
+
+# All frameworks
+pip install ulinzilogs[all]
+```
+
+---
+
+## 🔑 Getting Your Project Key
+
+After installing, run:
+
+```bash
+ulinzi-init
+```
+
+This generates a **unique Project Key** for your app and prints setup instructions.
+
+> ⚠️ **Important:** This key is generated locally on your machine.
+> To activate it, copy the key and register it at **[ulinzilogs.com](https://ulinzilogs.com)**.
+> Once registered, your dashboard will start receiving logs from your app.
+
+---
+
+## ⚙️ Setup & Usage
+
+### 🟢 FastAPI
+
+```python
+from fastapi import FastAPI
+from ulinzilogs import UlinziFastAPIMiddleware
+
+app = FastAPI()
+
+app.add_middleware(
+    UlinziFastAPIMiddleware,
+    api_key="YOUR_ULINZI_KEY"
+)
+
+@app.get("/")
+async def root():
+    return {"message": "Protected by Ulinzi"}
+```
+
+---
+
+### 🔵 Flask
+
+```python
+from flask import Flask
+from ulinzilogs import UlinziFlaskMiddleware
+
+app = Flask(__name__)
+UlinziFlaskMiddleware(app, api_key="YOUR_ULINZI_KEY")
+
+@app.route("/")
+def hello():
+    return "Protected by Ulinzi"
+```
+
+---
+
+### 🟣 Django
+
+In `settings.py`:
+
+```python
+MIDDLEWARE = [
+    # ... other middleware
+    'ulinzilogs.UlinziDjangoMiddleware',
+]
+
+ULINZI_API_KEY = "YOUR_ULINZI_KEY"
+ULINZI_APP_NAME = "MyDjangoApp"   # optional label shown in dashboard
+```
+
+---
+
+## 🧠 How Ulinzilogs Works
+Client Request
+│
+▼
+┌───────────────┐
+│   Middleware  │
+└──────┬────────┘
+│
+▼
+┌────────────────────┐
+│  Redact Sensitive  │
+│  Fields & Headers  │
+└──────┬─────────────┘
+│
+▼   (Background Thread)
+┌────────────────────┐
+│  Send to Ulinzi    │
+│  Security API      │
+└──────┬─────────────┘
+│
+▼
+┌────────────────────┐
+│ AI Threat Analysis │
+│ (SQLi, XSS, etc.)  │
+└────────────────────┘
+
+1. **Intercept** — Captures request metadata (IP, URL, method, body).
+2. **Redact** — Removes secrets before transmission.
+3. **Dispatch** — Sends logs asynchronously in a background thread.
+4. **Analyze** — Central AI scans for malicious patterns.
+
+---
+
+## 🔐 Sensitive Data Protection
+
+The following keys are **automatically redacted**:
+
+| Field | Redacted? |
+|-------|-----------|
+| `password` | ✅ Yes |
+| `secret` | ✅ Yes |
+| `token` | ✅ Yes |
+| `key` | ✅ Yes |
+| `cvv` | ✅ Yes |
+| `api_key` | ✅ Yes |
+
+Example:
+
+```json
+{
+  "email": "user@mail.com",
+  "password": "[REDACTED]"
+}
+```
+
+Your users' secrets **never leave your server in plaintext**.
+
+---
+
+## ⚡ Performance Philosophy
+
+* No request blocking
+* No database writes on your server
+* No logging delays
+
+Ulinzilogs runs **beside** your app — not **inside** its critical path.
+
+---
+
+## 🧩 Package Structure
+ulinzilogs/
+├── init.py
+├── middleware.py
+├── utils.py
+├── cli.py
+├── pyproject.toml
+└── README.md
+
+---
+
+## 📜 License
+
+Copyright (c) 2026 PashyGeek. Licensed under the MIT License — see the LICENSE file for details.

ulinzilogs-0.1.1/pyproject.toml

@@ -0,0 +1,28 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "ulinzilogs"
+version = "0.1.1"
+authors = [
+  { name="PashyGeek", email="codyypashy@gmail.com" },
+]
+description = "Security logging middleware for FastAPI, Flask, and Django"
+readme = "README.md"
+requires-python = ">=3.8"
+dependencies = [
+    "requests>=2.28.0",
+]
+
+[project.optional-dependencies]
+fastapi = ["starlette>=0.20.0"]
+flask = ["flask>=2.0.0"]
+django = ["django>=3.2"]
+all = ["starlette>=0.20.0", "flask>=2.0.0", "django>=3.2"]
+
+[project.scripts]
+ulinzi-init = "ulinzilogs.cli:main"
+
+[project.urls]
+"Homepage" = "https://github.com/PashyGeek/ulinzilogs"

ulinzilogs-0.1.1/setup.cfg

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

ulinzilogs-0.1.1/ulinzilogs/__init__.py

@@ -0,0 +1,4 @@
+from .middleware import UlinziFastAPIMiddleware, UlinziFlaskMiddleware, UlinziDjangoMiddleware
+
+# Alias for general use
+UlinziMiddleware = UlinziFastAPIMiddleware

ulinzilogs-0.1.1/ulinzilogs/cli.py

@@ -0,0 +1,39 @@
+import uuid
+import sys
+
+def main():
+    """
+    Generates a unique project key and prints setup instructions.
+    """
+    project_key = str(uuid.uuid4())
+    
+    print("\n" + "="*60)
+    print("   🛡️   ULINZI LOGS PACKAGED INSTALLED SUCCESSFULLY!   🛡️")
+    print("="*60)
+    print(f"\n🔑 YOUR UNIQUE PROJECT KEY:  {project_key}\n")
+    print("PLEASE SAVE THIS KEY! You will need it to configure your app.")
+    print("-" * 60)
+    
+    print("\n📋 NEXT STEPS:\n")
+    
+    print("1️⃣  Django Configuration (settings.py):")
+    print(f"    ULINZI_API_KEY = '{project_key}'")
+    print("    MIDDLEWARE = [")
+    print("        ...,")
+    print("        'ulinzilogs.middleware.UlinziDjangoMiddleware',")
+    print("    ]")
+    
+    print("\n2️⃣  FastAPI Configuration:")
+    print("    from ulinzilogs.middleware import UlinziFastAPIMiddleware")
+    print("    app = FastAPI()")
+    print(f"    app.add_middleware(UlinziFastAPIMiddleware, api_key='{project_key}')")
+    
+    print("\n3️⃣  Flask Configuration:")
+    print("    from ulinzilogs.middleware import UlinziFlaskMiddleware")
+    print("    app = Flask(__name__)")
+    print(f"    UlinziFlaskMiddleware(app, api_key='{project_key}')")
+    
+    print("\n" + "="*60 + "\n")
+
+if __name__ == "__main__":
+    main()

ulinzilogs-0.1.1/ulinzilogs/middleware.py

@@ -0,0 +1,136 @@
+import json
+import threading
+import requests
+from .utils import redact_sensitive_data
+
+# --- The "Universal" Core ---
+class UlinziLogger:
+    def __init__(self, api_key: str, app_name: str = "Unknown App", ingest_url: str = None):
+        self.api_key = api_key
+        self.app_name = app_name
+        self.ingest_url = ingest_url or "https://api.ulinzilogs.com/v1/ingest"
+
+    def send_logs(self, payload: dict):
+        if not self.api_key:
+            return
+        payload["app_name"] = self.app_name
+        try:
+            headers = {
+                "X-API-KEY": self.api_key,
+                "Content-Type": "application/json"
+            }
+            requests.post(self.ingest_url, json=payload, headers=headers, timeout=5)
+        except:
+            pass
+
+# --- 1. FastAPI / Starlette Flavor ---
+try:
+    from starlette.middleware.base import BaseHTTPMiddleware
+    HAS_STARLETTE = True
+except ImportError:
+    BaseHTTPMiddleware = object
+    HAS_STARLETTE = False
+
+class UlinziFastAPIMiddleware(BaseHTTPMiddleware):
+    def __init__(self, app, api_key: str, app_name: str = None):
+        if not HAS_STARLETTE:
+            raise ImportError(
+                "UlinziFastAPIMiddleware requires Starlette. "
+                "Install it with: pip install ulinzilogs[fastapi]"
+            )
+        super().__init__(app)
+        self.logger = UlinziLogger(api_key, app_name or "FastAPI-App")
+
+    async def dispatch(self, request, call_next):
+        log_data = {
+            "ip": request.client.host,
+            "method": request.method,
+            "url": str(request.url),
+            "host": request.headers.get("host"),
+            "user_agent": request.headers.get("user-agent"),
+            "headers": {k: v for k, v in request.headers.items() if k.lower() not in ("authorization", "cookie")}
+        }
+        try:
+            body = await request.body()
+            if body:
+                request._body = body
+                log_data["body"] = redact_sensitive_data(json.loads(body))
+        except:
+            log_data["body"] = None
+
+        response = await call_next(request)
+        log_data["status_code"] = response.status_code
+        threading.Thread(target=self.logger.send_logs, args=(log_data,)).start()
+        return response
+
+# --- 2. Flask Flavor ---
+try:
+    from flask import request as flask_request
+    HAS_FLASK = True
+except ImportError:
+    HAS_FLASK = False
+
+class UlinziFlaskMiddleware:
+    def __init__(self, app, api_key: str, app_name: str = None):
+        if not HAS_FLASK:
+            raise ImportError(
+                "UlinziFlaskMiddleware requires Flask. "
+                "Install it with: pip install ulinzilogs[flask]"
+            )
+        self.app = app
+        self.logger = UlinziLogger(api_key, app_name or "Flask-App")
+
+        @app.after_request
+        def after_request(response):
+            log_data = {
+                "ip": flask_request.remote_addr,
+                "method": flask_request.method,
+                "url": flask_request.url,
+                "host": flask_request.host,
+                "user_agent": flask_request.headers.get("User-Agent"),
+                "headers": {k: v for k, v in flask_request.headers.items() if k.lower() not in ("authorization", "cookie")},
+                "status_code": response.status_code
+            }
+            if flask_request.is_json:
+                try:
+                    log_data["body"] = redact_sensitive_data(flask_request.get_json())
+                except:
+                    log_data["body"] = None
+            threading.Thread(target=self.logger.send_logs, args=(log_data,)).start()
+            return response
+
+# --- 3. Django Flavor ---
+class UlinziDjangoMiddleware:
+    def __init__(self, get_response):
+        self.get_response = get_response
+        try:
+            from django.conf import settings
+            self.api_key = getattr(settings, "ULINZI_API_KEY", None)
+            self.app_name = getattr(settings, "ULINZI_APP_NAME", "Django-App")
+            self.ingest_url = getattr(settings, "ULINZI_INGEST_URL", None)  # FOR TESTING PURPOSES ONLY
+        except ImportError:
+            raise ImportError(
+                "UlinziDjangoMiddleware requires Django. "
+                "Install it with: pip install ulinzilogs[django]"
+            )
+        self.logger = UlinziLogger(self.api_key, self.app_name, self.ingest_url)
+
+    def __call__(self, request):
+        log_data = {
+            "ip": request.META.get('REMOTE_ADDR'),
+            "method": request.method,
+            "url": request.build_absolute_uri(),
+            "host": request.get_host(),
+            "user_agent": request.META.get('HTTP_USER_AGENT'),
+            "headers": {k: v for k, v in request.headers.items() if k.lower() not in ("authorization", "cookie")}
+        }
+        if request.body:
+            try:
+                log_data["body"] = redact_sensitive_data(json.loads(request.body))
+            except:
+                log_data["body"] = None
+
+        response = self.get_response(request)
+        log_data["status_code"] = response.status_code
+        threading.Thread(target=self.logger.send_logs, args=(log_data,)).start()
+        return response

ulinzilogs-0.1.1/ulinzilogs/utils.py

@@ -0,0 +1,19 @@
+import json
+from typing import Any
+
+def redact_sensitive_data(data: Any) -> Any:
+    """
+    Recursively scans dictionaries/lists and replaces sensitive 
+    values with [REDACTED].
+    """
+    sensitive_keys = {'password', 'secret', 'token', 'key', 'cvv', 'api_key'}
+    
+    if isinstance(data, dict):
+        return {
+            k: ("[REDACTED]" if k.lower() in sensitive_keys else redact_sensitive_data(v))
+            for k, v in data.items()
+        }
+    elif isinstance(data, list):
+        return [redact_sensitive_data(item) for item in data]
+    
+    return data

ulinzilogs-0.1.1/ulinzilogs.egg-info/PKG-INFO

@@ -0,0 +1,219 @@
+Metadata-Version: 2.4
+Name: ulinzilogs
+Version: 0.1.1
+Summary: Security logging middleware for FastAPI, Flask, and Django
+Author-email: PashyGeek <codyypashy@gmail.com>
+Project-URL: Homepage, https://github.com/PashyGeek/ulinzilogs
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: requests>=2.28.0
+Provides-Extra: fastapi
+Requires-Dist: starlette>=0.20.0; extra == "fastapi"
+Provides-Extra: flask
+Requires-Dist: flask>=2.0.0; extra == "flask"
+Provides-Extra: django
+Requires-Dist: django>=3.2; extra == "django"
+Provides-Extra: all
+Requires-Dist: starlette>=0.20.0; extra == "all"
+Requires-Dist: flask>=2.0.0; extra == "all"
+Requires-Dist: django>=3.2; extra == "all"
+
+# Ulinzilogs 🛡️
+
+> **Lightweight, non‑blocking security logging middleware for Python web apps**
+> Built for developers who want **visibility without performance pain**.
+
+---
+
+## 🌍 What is Ulinzilogs?
+
+**Ulinzilogs** is a security‑focused middleware that silently watches incoming HTTP requests in your Python web application, **redacts sensitive data**, and **ships sanitized logs** to the Ulinzi Security API for **AI‑powered threat analysis**.
+
+Think of it as:
+
+> 🔐 *A security camera for your API — always on, never in the way.*
+
+---
+
+## ✨ Key Features
+
+* 🚀 **Non‑Blocking by Design** — Uses background threads so your request/response cycle stays fast.
+* 🔒 **Automatic Data Redaction** — Sensitive fields are replaced with `[REDACTED]` before leaving your server.
+* 🌐 **Multi‑Framework Support** — Works out of the box with FastAPI, Flask, and Django.
+* 🧹 **Clean & Safe Headers** — Excludes `Authorization` and `Cookie` headers automatically.
+
+---
+
+## 📦 Installation
+
+Install only what your stack needs:
+
+```bash
+# FastAPI / Starlette
+pip install ulinzilogs[fastapi]
+
+# Flask
+pip install ulinzilogs[flask]
+
+# Django
+pip install ulinzilogs[django]
+
+# All frameworks
+pip install ulinzilogs[all]
+```
+
+---
+
+## 🔑 Getting Your Project Key
+
+After installing, run:
+
+```bash
+ulinzi-init
+```
+
+This generates a **unique Project Key** for your app and prints setup instructions.
+
+> ⚠️ **Important:** This key is generated locally on your machine.
+> To activate it, copy the key and register it at **[ulinzilogs.com](https://ulinzilogs.com)**.
+> Once registered, your dashboard will start receiving logs from your app.
+
+---
+
+## ⚙️ Setup & Usage
+
+### 🟢 FastAPI
+
+```python
+from fastapi import FastAPI
+from ulinzilogs import UlinziFastAPIMiddleware
+
+app = FastAPI()
+
+app.add_middleware(
+    UlinziFastAPIMiddleware,
+    api_key="YOUR_ULINZI_KEY"
+)
+
+@app.get("/")
+async def root():
+    return {"message": "Protected by Ulinzi"}
+```
+
+---
+
+### 🔵 Flask
+
+```python
+from flask import Flask
+from ulinzilogs import UlinziFlaskMiddleware
+
+app = Flask(__name__)
+UlinziFlaskMiddleware(app, api_key="YOUR_ULINZI_KEY")
+
+@app.route("/")
+def hello():
+    return "Protected by Ulinzi"
+```
+
+---
+
+### 🟣 Django
+
+In `settings.py`:
+
+```python
+MIDDLEWARE = [
+    # ... other middleware
+    'ulinzilogs.UlinziDjangoMiddleware',
+]
+
+ULINZI_API_KEY = "YOUR_ULINZI_KEY"
+ULINZI_APP_NAME = "MyDjangoApp"   # optional label shown in dashboard
+```
+
+---
+
+## 🧠 How Ulinzilogs Works
+Client Request
+│
+▼
+┌───────────────┐
+│   Middleware  │
+└──────┬────────┘
+│
+▼
+┌────────────────────┐
+│  Redact Sensitive  │
+│  Fields & Headers  │
+└──────┬─────────────┘
+│
+▼   (Background Thread)
+┌────────────────────┐
+│  Send to Ulinzi    │
+│  Security API      │
+└──────┬─────────────┘
+│
+▼
+┌────────────────────┐
+│ AI Threat Analysis │
+│ (SQLi, XSS, etc.)  │
+└────────────────────┘
+
+1. **Intercept** — Captures request metadata (IP, URL, method, body).
+2. **Redact** — Removes secrets before transmission.
+3. **Dispatch** — Sends logs asynchronously in a background thread.
+4. **Analyze** — Central AI scans for malicious patterns.
+
+---
+
+## 🔐 Sensitive Data Protection
+
+The following keys are **automatically redacted**:
+
+| Field | Redacted? |
+|-------|-----------|
+| `password` | ✅ Yes |
+| `secret` | ✅ Yes |
+| `token` | ✅ Yes |
+| `key` | ✅ Yes |
+| `cvv` | ✅ Yes |
+| `api_key` | ✅ Yes |
+
+Example:
+
+```json
+{
+  "email": "user@mail.com",
+  "password": "[REDACTED]"
+}
+```
+
+Your users' secrets **never leave your server in plaintext**.
+
+---
+
+## ⚡ Performance Philosophy
+
+* No request blocking
+* No database writes on your server
+* No logging delays
+
+Ulinzilogs runs **beside** your app — not **inside** its critical path.
+
+---
+
+## 🧩 Package Structure
+ulinzilogs/
+├── init.py
+├── middleware.py
+├── utils.py
+├── cli.py
+├── pyproject.toml
+└── README.md
+
+---
+
+## 📜 License
+
+Copyright (c) 2026 PashyGeek. Licensed under the MIT License — see the LICENSE file for details.

ulinzilogs-0.1.1/ulinzilogs.egg-info/SOURCES.txt

@@ -0,0 +1,12 @@
+README.md
+pyproject.toml
+ulinzilogs/__init__.py
+ulinzilogs/cli.py
+ulinzilogs/middleware.py
+ulinzilogs/utils.py
+ulinzilogs.egg-info/PKG-INFO
+ulinzilogs.egg-info/SOURCES.txt
+ulinzilogs.egg-info/dependency_links.txt
+ulinzilogs.egg-info/entry_points.txt
+ulinzilogs.egg-info/requires.txt
+ulinzilogs.egg-info/top_level.txt

ulinzilogs-0.1.1/ulinzilogs.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

ulinzilogs-0.1.1/ulinzilogs.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+ulinzi-init = ulinzilogs.cli:main

ulinzilogs-0.1.1/ulinzilogs.egg-info/requires.txt

@@ -0,0 +1,15 @@
+requests>=2.28.0
+
+[all]
+starlette>=0.20.0
+flask>=2.0.0
+django>=3.2
+
+[django]
+django>=3.2
+
+[fastapi]
+starlette>=0.20.0
+
+[flask]
+flask>=2.0.0

ulinzilogs-0.1.1/ulinzilogs.egg-info/top_level.txt

@@ -0,0 +1 @@
+ulinzilogs