tracelite 0.1.0__tar.gz

tracelite-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Yeongseon Choe
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

tracelite-0.1.0/PKG-INFO

@@ -0,0 +1,98 @@
+Metadata-Version: 2.3
+Name: tracelite
+Version: 0.1.0
+Summary: Lightweight request & response tracing for your Flask, Django, or FastAPI dev server
+License: MIT
+Author: Yeongseon Choe
+Author-email: yeongseon.choe@gmail.com
+Requires-Python: >=3.9,<4.0
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+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: Programming Language :: Python :: 3.13
+Provides-Extra: django
+Provides-Extra: fastapi
+Requires-Dist: pydantic (>=2.6,<3.0)
+Requires-Dist: rich (>=13.7,<14.0)
+Requires-Dist: sqlalchemy (>=2.0,<3.0)
+Requires-Dist: tomli (>=2.0,<3.0)
+Requires-Dist: typer (>=0.15,<0.16)
+Description-Content-Type: text/markdown
+
+# README.md
+# Tracelite
+
+**Lightweight request & response tracing for your Flask, Django, or FastAPI dev server**
+
+Tracelite logs incoming HTTP requests and outgoing responses in a structured format. It's ideal for local development and debugging.
+
+## Features
+- 🔍 Logs method, path, status, duration, client IP, headers, body
+- ⚙️ Configurable masking and path exclusion (via `tracelite.toml`)
+- 📦 SQLite-based local storage
+- 📊 Pretty CLI output using `rich`
+
+## Installation
+```bash
+pip install tracelite[flask]
+```
+
+## Usage
+### CLI
+```bash
+tracelite view
+tracelite export --format json
+```
+
+### Flask Integration
+```python
+from flask import Flask
+from tracelite.middleware.flask import TraceliteMiddleware
+from tracelite.core.storage.sqlite import SQLiteStorage
+from tracelite.core.config import load_config
+
+app = Flask(__name__)
+config = load_config()
+storage = SQLiteStorage(db_path=config.db_path)
+
+app.wsgi_app = TraceliteMiddleware(app.wsgi_app, storage, config)
+```
+
+## Configuration (tracelite.toml)
+```toml
+[storage]
+type = "sqlite"
+path = "tracelite.db"
+
+[filter]
+exclude_paths = ["/static", "/favicon.ico"]
+mask_keys = ["password", "token"]
+```
+
+## Testing
+```bash
+poetry install --with dev
+pytest
+```
+
+## Coverage Report
+```bash
+open htmlcov/index.html
+```
+
+## Requirementsgit add .
+git commit -m "release: v0.1.0"
+git push origin main
+git tag v0.1.0
+git push origin v0.1.0
+
+- Python 3.9+
+- Flask 3.x
+
+---
+
+MIT © Yeongseon Choe
+

tracelite-0.1.0/README.md

@@ -0,0 +1,73 @@
+# README.md
+# Tracelite
+
+**Lightweight request & response tracing for your Flask, Django, or FastAPI dev server**
+
+Tracelite logs incoming HTTP requests and outgoing responses in a structured format. It's ideal for local development and debugging.
+
+## Features
+- 🔍 Logs method, path, status, duration, client IP, headers, body
+- ⚙️ Configurable masking and path exclusion (via `tracelite.toml`)
+- 📦 SQLite-based local storage
+- 📊 Pretty CLI output using `rich`
+
+## Installation
+```bash
+pip install tracelite[flask]
+```
+
+## Usage
+### CLI
+```bash
+tracelite view
+tracelite export --format json
+```
+
+### Flask Integration
+```python
+from flask import Flask
+from tracelite.middleware.flask import TraceliteMiddleware
+from tracelite.core.storage.sqlite import SQLiteStorage
+from tracelite.core.config import load_config
+
+app = Flask(__name__)
+config = load_config()
+storage = SQLiteStorage(db_path=config.db_path)
+
+app.wsgi_app = TraceliteMiddleware(app.wsgi_app, storage, config)
+```
+
+## Configuration (tracelite.toml)
+```toml
+[storage]
+type = "sqlite"
+path = "tracelite.db"
+
+[filter]
+exclude_paths = ["/static", "/favicon.ico"]
+mask_keys = ["password", "token"]
+```
+
+## Testing
+```bash
+poetry install --with dev
+pytest
+```
+
+## Coverage Report
+```bash
+open htmlcov/index.html
+```
+
+## Requirementsgit add .
+git commit -m "release: v0.1.0"
+git push origin main
+git tag v0.1.0
+git push origin v0.1.0
+
+- Python 3.9+
+- Flask 3.x
+
+---
+
+MIT © Yeongseon Choe

tracelite-0.1.0/pyproject.toml

@@ -0,0 +1,34 @@
+[tool.poetry]
+name = "tracelite"
+version = "0.1.0"
+description = "Lightweight request & response tracing for your Flask, Django, or FastAPI dev server"
+authors = ["Yeongseon Choe <yeongseon.choe@gmail.com>"]
+license = "MIT"
+readme = "README.md"
+packages = [
+  { include = "tracelite", from = "src" }
+]
+
+[tool.poetry.dependencies]
+python = ">=3.9,<4.0"
+pydantic = "^2.6"
+typer = "^0.15"
+rich = "^13.7"
+sqlalchemy = "^2.0"
+tomli = "^2.0"
+
+[tool.poetry.group.dev.dependencies]
+pytest = "^8.3.5"
+pytest-cov = "^5.0.0"
+flask = "^3.0"
+
+[tool.poetry.extras]
+django = ["django"]
+fastapi = ["fastapi", "starlette"]
+
+[tool.poetry.scripts]
+tracelite = "tracelite.cli.main:app"
+
+[build-system]
+requires = ["poetry-core"]
+build-backend = "poetry.core.masonry.api"

tracelite-0.1.0/src/tracelite/cli/main.py

@@ -0,0 +1,58 @@
+import typer
+import logging
+from tracelite.core.config import load_config
+from tracelite.core.storage.sqlite import SQLiteStorage
+
+app = typer.Typer()
+
+# Load configuration from file
+config = load_config()
+
+# Initialize storage based on config
+db_path = config.db_path
+storage = SQLiteStorage(db_path=db_path)
+
+# Set up basic logging
+logging.basicConfig(level=logging.INFO, format="[%(levelname)s] %(message)s")
+
+@app.command()
+def view(since: int = 3600):
+    """View logs from the last N seconds."""
+    logs = storage.fetch_recent(since_seconds=since)
+    if not logs:
+        logging.info("No logs found.")
+        return
+
+    import rich
+    from rich.table import Table
+    from rich.console import Console
+
+    table = Table(show_header=True, header_style="bold magenta")
+    table.add_column("Timestamp")
+    table.add_column("Method")
+    table.add_column("Path")
+    table.add_column("Status")
+    table.add_column("Duration (ms)", justify="right")
+
+    for row in logs:
+        timestamp, method, path, status_code, *_ , duration_ms = row
+        table.add_row(timestamp, method, path, str(status_code), f"{duration_ms:.2f}")
+
+    console = Console()
+    console.print(table)
+
+@app.command()
+def export(format: str = "json"):
+    """Export logs to given format."""
+    try:
+        output = storage.export(format)
+        from rich import print_json
+        if format == "json":
+            print_json(output)
+        else:
+            print(output)
+    except Exception as e:
+        logging.error(f"Export failed: {e}")
+        
+if __name__ == "__main__":
+    app()

tracelite-0.1.0/src/tracelite/core/config.py

@@ -0,0 +1,23 @@
+import tomli
+from pathlib import Path
+from typing import List
+
+class AppConfig:
+    def __init__(self, db_path: str, exclude_paths: List[str], mask_keys: List[str]):
+        self.db_path = db_path
+        self.exclude_paths = exclude_paths
+        self.mask_keys = mask_keys
+
+def load_config(file_path: str = "tracelite.toml") -> AppConfig:
+    config_path = Path(file_path)
+    if not config_path.exists():
+        raise FileNotFoundError(f"Configuration file not found: {file_path}")
+
+    with config_path.open("rb") as f:
+        data = tomli.load(f)
+
+    db_path = data.get("storage", {}).get("path", "tracelite.db")
+    exclude_paths = data.get("filter", {}).get("exclude_paths", [])
+    mask_keys = data.get("filter", {}).get("mask_keys", [])
+
+    return AppConfig(db_path=db_path, exclude_paths=exclude_paths, mask_keys=mask_keys)

tracelite-0.1.0/src/tracelite/core/filters.py

@@ -0,0 +1,10 @@
+def should_exclude(path: str, exclude_paths: list) -> bool:
+    """Return True if the path should be excluded from logging."""
+    return any(path.startswith(p) for p in exclude_paths)
+
+def mask_sensitive(data: dict, keys_to_mask: list, mask: str = "***") -> dict:
+    """Return a copy of the data with sensitive keys masked."""
+    return {
+        k: (mask if k.lower() in [m.lower() for m in keys_to_mask] else v)
+        for k, v in data.items()
+    }

tracelite-0.1.0/src/tracelite/core/models.py

@@ -0,0 +1,18 @@
+# models.py
+from dataclasses import dataclass, field
+from datetime import datetime
+from typing import Dict, Optional
+
+@dataclass
+class RequestLog:
+    timestamp: datetime
+    method: str
+    path: str
+    status_code: int
+    client_ip: str
+    user_agent: Optional[str] = None
+    request_headers: Dict[str, str] = field(default_factory=dict)
+    request_body: Optional[str] = None
+    response_headers: Dict[str, str] = field(default_factory=dict)
+    response_body: Optional[str] = None
+    duration_ms: Optional[float] = None

tracelite-0.1.0/src/tracelite/core/storage/base.py

@@ -0,0 +1,19 @@
+# base.py
+from abc import ABC, abstractmethod
+from tracelite.core.models import RequestLog
+
+class ILoggerStorage(ABC):
+    @abstractmethod
+    def store(self, log: RequestLog) -> None:
+        """Store a single request log entry."""
+        pass
+
+    @abstractmethod
+    def fetch_recent(self, since_seconds: int = 3600) -> list:
+        """Fetch logs from the last N seconds."""
+        pass
+
+    @abstractmethod
+    def export(self, format: str = "json") -> str:
+        """Export all logs to JSON, CSV, etc."""
+        pass

tracelite-0.1.0/src/tracelite/core/storage/sqlite.py

@@ -0,0 +1,68 @@
+import sqlite3
+from tracelite.core.models import RequestLog
+from tracelite.core.storage.base import ILoggerStorage
+from datetime import datetime
+import json
+
+class SQLiteStorage(ILoggerStorage):
+    def __init__(self, db_path: str = "tracelite.db"):
+        self.conn = sqlite3.connect(db_path, check_same_thread=False)
+        self._create_table()
+
+    def _create_table(self):
+        with self.conn:
+            self.conn.execute("""
+            CREATE TABLE IF NOT EXISTS request_logs (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                timestamp TEXT,
+                method TEXT,
+                path TEXT,
+                status_code INTEGER,
+                client_ip TEXT,
+                user_agent TEXT,
+                request_headers TEXT,
+                request_body TEXT,
+                response_headers TEXT,
+                response_body TEXT,
+                duration_ms REAL
+            )
+            """)
+
+    def store(self, log: RequestLog) -> None:
+        with self.conn:
+            self.conn.execute("""
+            INSERT INTO request_logs (
+                timestamp, method, path, status_code, client_ip, user_agent,
+                request_headers, request_body, response_headers, response_body, duration_ms
+            ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+            """, (
+                log.timestamp.isoformat(),
+                log.method,
+                log.path,
+                log.status_code,
+                log.client_ip,
+                log.user_agent,
+                json.dumps(log.request_headers),
+                log.request_body,
+                json.dumps(log.response_headers),
+                log.response_body,
+                log.duration_ms,
+            ))
+
+    def fetch_recent(self, since_seconds: int = 3600) -> list:
+        cutoff = datetime.utcnow().timestamp() - since_seconds
+        with self.conn:
+            rows = self.conn.execute("""
+            SELECT * FROM request_logs WHERE strftime('%s', timestamp) >= ?
+            ORDER BY timestamp DESC
+            """, (int(cutoff),)).fetchall()
+        return rows
+
+    def export(self, format: str = "json") -> str:
+        with self.conn:
+            rows = self.conn.execute("SELECT * FROM request_logs").fetchall()
+        if format == "json":
+            columns = [col[0] for col in self.conn.execute("PRAGMA table_info(request_logs)")]
+            return json.dumps([dict(zip(columns, row)) for row in rows], indent=2)
+        else:
+            raise ValueError("Unsupported export format")

tracelite-0.1.0/src/tracelite/middleware/flask.py

@@ -0,0 +1,40 @@
+from flask import request
+from tracelite.core.models import RequestLog
+from tracelite.core.filters import should_exclude, mask_sensitive
+from tracelite.core.config import AppConfig
+import time
+from datetime import datetime
+
+class TraceliteMiddleware:
+    def __init__(self, app, storage, config: AppConfig):
+        self.app = app
+        self.storage = storage
+        self.config = config
+
+    def __call__(self, environ, start_response):
+        start_time = time.time()
+        req = request
+
+        if should_exclude(req.path, self.config.exclude_paths):
+            return self.app(environ, start_response)
+
+        def custom_start_response(status, headers, exc_info=None):
+            response_status = int(status.split(" ")[0])
+            duration = (time.time() - start_time) * 1000
+            log = RequestLog(
+                timestamp=datetime.utcnow(),
+                method=req.method,
+                path=req.path,
+                status_code=response_status,
+                client_ip=req.remote_addr,
+                user_agent=req.headers.get("User-Agent"),
+                request_headers=mask_sensitive(dict(req.headers), self.config.mask_keys),
+                request_body=req.get_data(as_text=True),
+                response_headers=dict(headers),
+                response_body=None,  # capturing response body is omitted due to complexity
+                duration_ms=duration,
+            )
+            self.storage.store(log)
+            return start_response(status, headers, exc_info)
+
+        return self.app(environ, custom_start_response)