ganicas-package 0.1.4__py3-none-any.whl → 0.2.0__py3-none-any.whl

ganicas_package-0.2.0.dist-info/METADATA

@@ -0,0 +1,443 @@
+Metadata-Version: 2.1
+Name: ganicas-package
+Version: 0.2.0
+Summary: Ganicas internal Python package for structured logging and utilities.
+Keywords: logging,utilities,internal-package,structlog,middleware,fastapi,flask
+Author: Ganicas
+Requires-Python: >=3.11,<4.0
+Classifier: Development Status :: 3 - Alpha
+Classifier: Framework :: FastAPI
+Classifier: Framework :: Flask
+Classifier: Intended Audience :: Developers
+Classifier: License :: Other/Proprietary License
+Classifier: Natural Language :: English
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: System :: Logging
+Requires-Dist: fastapi (>=0.114.2,<0.116.0)
+Requires-Dist: flask (>=2.2.0,<3.0.0)
+Requires-Dist: httpx (>=0.28.1,<0.29.0)
+Requires-Dist: python-json-logger (>=3.2.1,<4.0.0)
+Requires-Dist: structlog (>=24.4.0,<25.0.0)
+Description-Content-Type: text/markdown
+
+# Ganicas Utils
+
+[![Python Version](https://img.shields.io/badge/python-3.11%2B-blue.svg)](https://www.python.org/downloads/)
+[![License](https://img.shields.io/badge/license-Proprietary-red.svg)](LICENSE)
+[![Code Coverage](https://img.shields.io/badge/coverage-99%25-brightgreen.svg)](https://github.com/ganicas/ganicas_utils)
+
+**Ganicas Utils** is an internal Python package providing structured logging utilities and middleware for Flask and FastAPI applications. Built on top of [structlog](https://www.structlog.org/), it enables production-ready, context-aware logging with minimal configuration.
+
+---
+
+## 📋 Table of Contents
+
+- [Features](#-features)
+- [Installation](#-installation)
+- [Quick Start](#-quick-start)
+- [Structured Logging](#-structured-logging)
+  - [Basic Configuration](#basic-configuration)
+  - [Production Configuration](#production-configuration)
+- [Middleware](#-middleware)
+  - [Flask Middleware](#flask-middleware)
+  - [FastAPI Middleware](#fastapi-middleware)
+  - [Request Logging Middleware](#request-logging-middleware)
+- [Why Structured Logging?](#-why-structured-logging)
+- [Development](#-development)
+- [License](#-license)
+
+---
+
+## ✨ Features
+
+- **Structured Logging**: JSON-formatted logs for easy parsing by log aggregation tools (ELK, Datadog, Grafana Loki)
+- **Context Management**: Automatic request context binding (request_id, IP, user_agent, etc.)
+- **Flask & FastAPI Support**: Ready-to-use middleware for both frameworks
+- **Advanced Request Logging**: Comprehensive ASGI middleware with:
+  - Automatic request/response logging
+  - Sensitive header sanitization
+  - Slow request detection
+  - Sampling for high-traffic endpoints
+  - Exception tracking with full context
+  - Distributed tracing support (traceparent header)
+- **Production Ready**: Battle-tested with 99% code coverage
+
+---
+
+## 📦 Installation
+
+```bash
+pip install ganicas-package
+```
+
+Or with Poetry:
+
+```bash
+poetry add ganicas-package
+```
+
+---
+
+## 🚀 Quick Start
+
+### Basic Configuration
+
+Replace `logger = logging.getLogger(__name__)` with `logger = structlog.get_logger(__name__)`:
+
+```python
+from ganicas_utils.logging import LoggingConfigurator
+from ganicas_utils.config import Config
+import structlog
+
+config = Config()
+
+LoggingConfigurator(
+    service_name=config.APP_NAME,
+    log_level='INFO',
+    setup_logging_dict=True
+).configure_structlog(
+    formatter='plain_console',
+    formatter_std_lib='plain_console'
+)
+
+logger = structlog.get_logger(__name__)
+logger.info("Application started", version="1.0.0", environment="production")
+```
+
+![basic example](images/plain_console_logger.png)
+
+---
+
+## 📊 Structured Logging
+
+### Production Configuration
+
+For production environments, use JSON formatting for machine-readable logs:
+
+```python
+from ganicas_utils.logging import LoggingConfigurator
+from ganicas_utils.config import Config
+import structlog
+
+config = Config()
+
+LoggingConfigurator(
+    service_name=config.APP_NAME,
+    log_level='INFO',
+    setup_logging_dict=True
+).configure_structlog(
+    formatter='json_formatter',
+    formatter_std_lib='json_formatter'
+)
+
+logger = structlog.get_logger(__name__)
+logger.info("User login", user_id=12345, ip_address="192.168.1.1")
+logger.warning("High memory usage", memory_percent=85.5, threshold=80)
+logger.error("Database connection failed", db_host="localhost", error_code="CONN_REFUSED")
+
+try:
+    result = 1 / 0
+except ZeroDivisionError:
+    logger.exception("Division by zero error", operation="calculate_ratio")
+```
+
+![logger with different keys](images/json_logger.png)
+
+
+---
+
+## 🔧 Middleware
+
+### Flask Middleware
+
+The `FlaskRequestContextMiddleware` automatically adds request context to all logs:
+
+```python
+import uuid
+from flask import Flask
+from ganicas_utils.logging import LoggingConfigurator
+from ganicas_utils.logging.middlewares import FlaskRequestContextMiddleware
+from ganicas_utils.config import Config
+import structlog
+
+config = Config()
+
+LoggingConfigurator(
+    service_name=config.APP_NAME,
+    log_level="INFO",
+    setup_logging_dict=True,
+).configure_structlog(formatter='json_formatter', formatter_std_lib='json_formatter')
+
+logger = structlog.get_logger(__name__)
+
+app = Flask(__name__)
+app.wsgi_app = FlaskRequestContextMiddleware(app.wsgi_app)
+
+@app.route("/")
+def home():
+    logger.info("Processing request")  # Automatically includes request_id, method, path
+    return "Hello, World!"
+
+if __name__ == "__main__":
+    app.run()
+```
+
+![logger with context flask](images/flask_logger_with_context.png)
+
+**Automatic context injection:**
+- `request_id` - Unique identifier for each request
+- `request_method` - HTTP method (GET, POST, etc.)
+- `request_path` - Request URL path
+
+---
+
+### FastAPI Middleware
+
+#### Basic Context Middleware
+
+For simple request context binding, use `FastAPIRequestContextMiddleware`:
+
+```python
+from fastapi import FastAPI
+from ganicas_utils.logging import LoggingConfigurator
+from ganicas_utils.logging.middlewares import FastAPIRequestContextMiddleware
+from ganicas_utils.config import Config
+import structlog
+
+config = Config()
+
+LoggingConfigurator(
+    service_name=config.APP_NAME,
+    log_level="INFO",
+    setup_logging_dict=True,
+).configure_structlog(formatter='json_formatter', formatter_std_lib='json_formatter')
+
+logger = structlog.get_logger(__name__)
+app = FastAPI()
+app.add_middleware(FastAPIRequestContextMiddleware)
+
+@app.get("/")
+async def root():
+    logger.info("Processing request")  # Automatically includes request context
+    return {"message": "Hello World"}
+```
+
+![logger with context fastapi](images/fastapi_logger_with_context.png)
+
+---
+
+### Request Logging Middleware
+
+For production-grade request/response logging with advanced features, use `RequestLoggingMiddleware`:
+
+```python
+from fastapi import FastAPI
+from ganicas_utils.logging import LoggingConfigurator
+from ganicas_utils.logging.middlewares import RequestLoggingMiddleware
+import structlog
+
+LoggingConfigurator(
+    service_name="my-api",
+    log_level="INFO",
+    setup_logging_dict=True,
+).configure_structlog(formatter='json_formatter', formatter_std_lib='json_formatter')
+
+app = FastAPI()
+
+# Add comprehensive request logging
+app.add_middleware(
+    RequestLoggingMiddleware,
+    slow_request_threshold_ms=1000,      # Warn on requests > 1s
+    propagate_request_id=True,           # Add request_id to response headers
+    skip_paths={"/healthz", "/metrics"}, # Don't log health checks
+    sample_2xx_rate=0.1,                 # Sample 10% of successful requests
+)
+
+@app.get("/api/users/{user_id}")
+async def get_user(user_id: int):
+    return {"user_id": user_id, "name": "John Doe"}
+```
+
+#### Features
+
+**Automatic Logging:**
+- `request.start` - Logs when request begins
+- `request.end` - Logs when request completes (with status, duration, size)
+- `request.exception` - Logs unhandled exceptions with full traceback
+
+**Logged Information:**
+- Request: method, path, query params, client IP, user agent, content type/length
+- Response: status code, size, content type, duration
+- Headers: Sanitized request/response headers (for 4xx/5xx errors)
+- Performance: Request duration, slow request detection
+
+**Security:**
+- Automatic sanitization of sensitive headers (`Authorization`, `Cookie`, `X-API-Key`)
+- Authorization header preserves scheme: `Bearer ***` instead of exposing tokens
+- No request/response body logging (only sizes)
+
+**Performance Optimization:**
+- Skip logging for health checks and metrics endpoints
+- Sample successful requests to reduce log volume
+- Skip OPTIONS requests
+- Configurable path prefixes to skip
+
+**Distributed Tracing:**
+- Supports W3C `traceparent` header
+- Falls back to `x-request-id` or `x-amzn-trace-id`
+- Propagates request_id to response headers
+
+#### Configuration Options
+
+| Parameter | Type | Default | Description |
+|-----------|------|---------|-------------|
+| `logger` | `structlog.BoundLoggerBase` | `structlog.get_logger("http")` | Custom logger instance |
+| `slow_request_threshold_ms` | `int` | `None` | Threshold in ms to flag slow requests |
+| `propagate_request_id` | `bool` | `True` | Add `x-request-id` to response headers |
+| `skip_paths` | `set[str]` | `{"/healthz", "/metrics"}` | Exact paths to skip logging |
+| `skip_prefixes` | `tuple[str, ...]` | `("/metrics",)` | Path prefixes to skip logging |
+| `sample_2xx_rate` | `float` | `None` | Sample rate for 2xx/3xx responses (0.0-1.0) |
+
+#### Example Logs
+
+**Successful Request:**
+```json
+{
+  "event": "request.end",
+  "request_id": "550e8400-e29b-41d4-a716-446655440000",
+  "method": "GET",
+  "path": "/api/users/123",
+  "status_code": 200,
+  "duration_ms": 45,
+  "response_size": 256,
+  "client_ip": "192.168.1.100",
+  "user_agent": "Mozilla/5.0...",
+  "level": "info"
+}
+```
+
+**Slow Request Warning:**
+```json
+{
+  "event": "request.end",
+  "request_id": "550e8400-e29b-41d4-a716-446655440001",
+  "method": "POST",
+  "path": "/api/process",
+  "status_code": 200,
+  "duration_ms": 1523,
+  "slow_request": true,
+  "slow_threshold_ms": 1000,
+  "level": "warning"
+}
+```
+
+**Error with Sanitized Headers:**
+```json
+{
+  "event": "request.end",
+  "request_id": "550e8400-e29b-41d4-a716-446655440002",
+  "method": "POST",
+  "path": "/api/login",
+  "status_code": 401,
+  "duration_ms": 12,
+  "request_headers": {
+    "authorization": "Bearer ***",
+    "content-type": "application/json"
+  },
+  "level": "warning"
+}
+```
+
+---
+
+## 🎯 Why Structured Logging?
+
+**Traditional logging challenges:**
+- Plain text logs are hard to parse programmatically
+- Difficult to filter and search in log aggregation tools
+- Missing context makes debugging distributed systems challenging
+
+**Structured logging benefits:**
+- **Machine-readable**: JSON format for easy parsing by ELK, Datadog, Grafana Loki
+- **Rich context**: Automatic correlation with request_id, user_id, transaction_id
+- **Better filtering**: Query logs by any field (status_code, duration, user_id, etc.)
+- **Observability**: Enhanced monitoring and alerting capabilities
+- **Debugging**: Trace requests across microservices with distributed tracing support
+
+**This package uses [structlog](https://www.structlog.org/)** - a powerful library that enhances Python's standard logging with better context management and flexible log formatting.
+
+
+---
+
+## 🛠️ Development
+
+### Prerequisites
+
+Install [Poetry](https://python-poetry.org/docs/#installation) for dependency management:
+
+```bash
+curl -sSL https://install.python-poetry.org | python3 -
+```
+
+### Setup
+
+```bash
+# Install dependencies
+poetry install --with dev
+
+# Run tests with coverage
+poetry run pytest -v --cov=ganicas_utils
+
+# Run tests with detailed output
+poetry run pytest -rs --cov=ganicas_utils -s
+
+# Run pre-commit hooks
+poetry run pre-commit run --all-files
+```
+
+### Running Tests
+
+```bash
+# Run all tests
+poetry run pytest
+
+# Run specific test file
+poetry run pytest tests/test_request_logging_middleware.py
+
+# Run with coverage report
+poetry run pytest --cov=ganicas_utils --cov-report=html
+```
+
+### Code Quality
+
+This project uses:
+- **pytest** for testing (99% coverage)
+- **ruff** for linting and formatting
+- **pre-commit** for automated checks
+
+---
+
+## 📄 License
+
+Proprietary - Internal use only for Ganicas projects.
+
+---
+
+## 🤝 Contributing
+
+This is an internal package. For questions or contributions, please contact the Ganicas development team.
+
+---
+
+## 📚 Additional Resources
+
+- [structlog Documentation](https://www.structlog.org/en/stable/)
+- [FastAPI Middleware Guide](https://fastapi.tiangolo.com/tutorial/middleware/)
+- [Flask Middleware Guide](https://flask.palletsprojects.com/en/latest/api/#flask.Flask.wsgi_app)
+
+---
+
+**Made with ❤️ by Ganicas Team**
+

{ganicas_package-0.1.4.dist-info → ganicas_package-0.2.0.dist-info}/RECORD

@@ -3,9 +3,9 @@ ganicas_utils/config.py,sha256=-DUF1v0rlabzRGj8vt40-LQ4QwzbbKX9Ywetdu-yJW0,414
 ganicas_utils/logging/__init__.py,sha256=CoAyxkRoqIXqIHDtVHEP3VUb83455eQ7mdMoZw_H9gw,197
 ganicas_utils/logging/configuration.py,sha256=7IvdN7VBQ1gLSWXObEpCdV4L16mMK8KysiuyM4XM-1k,2068
 ganicas_utils/logging/formatter.py,sha256=1wfbKrXkbh_Xdz6ipX4ut7xAAWGhSTR00OEE6S7QuEU,592
-ganicas_utils/logging/logger.py,sha256=O7vJdOnxP49IBHMy7y8sG0nl2RbtmxfhdGh3Gw0wmDI,3338
-ganicas_utils/logging/middlewares.py,sha256=FIEn-qGTmZtoLfJcJDGLAG1PprgxCacE0e4wBt1C44Y,1546
+ganicas_utils/logging/logger.py,sha256=ablL50oJK2UNmHAJzUdWZKkz7VI99q32uP6cfLXUSVM,3340
+ganicas_utils/logging/middlewares.py,sha256=2901vY8f1eImpZO-CqO7p_pCkir07IdDauZqFdSablw,9401
 ganicas_utils/logging/utils.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-ganicas_package-0.1.4.dist-info/METADATA,sha256=3_Ile0FuYZZCRbEwOtR2sccid73Exl9YgbfItk79rho,9122
-ganicas_package-0.1.4.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-ganicas_package-0.1.4.dist-info/RECORD,,
+ganicas_package-0.2.0.dist-info/METADATA,sha256=U5cgWyIX8b8r2Tgc5kM5kzI4Nc7E6fll-HW59xWeT7E,12608
+ganicas_package-0.2.0.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+ganicas_package-0.2.0.dist-info/RECORD,,

ganicas_utils/logging/logger.py

@@ -1,11 +1,13 @@
-from typing import Optional
 import logging
 import logging.config
+from typing import Optional
+
 import structlog
 from structlog import contextvars
+from structlog.dev import ConsoleRenderer
 from structlog.typing import EventDict
+
 from ganicas_utils.logging.configuration import get_default_logging_conf
-from structlog.dev import ConsoleRenderer
 
 
 class LoggingConfigurator:

ganicas_utils/logging/middlewares.py

@@ -1,10 +1,12 @@
 import uuid
+from time import perf_counter
+from typing import Any, Optional
 
 import structlog
-from fastapi import Request
-from starlette.middleware.base import BaseHTTPMiddleware
+from starlette.types import Message, Receive, Scope, Send
 
 
+SENSITIVE_HEADERS = {"authorization", "cookie", "set-cookie", "x-api-key"}
 class FlaskRequestContextMiddleware:
     """Middleware for Flask to add request context to structlog."""
 
@@ -27,22 +29,220 @@ class FlaskRequestContextMiddleware:
         return self.app(environ, start_response)
 
 
-async def add_request_context_fastapi(request: Request, call_next):
-    """Middleware for FastAPI applications."""
-    request_id = request.headers.get("x-amzn-trace-id")
-    if not request_id:
-        request_id = str(uuid.uuid4())
+# --- ASGI Request Logging Middleware (FastAPI/Starlette) ---
 
-    structlog.contextvars.bind_contextvars(
-        request_id=request_id, request_method=request.method, request_path=str(request.url)
-    )
-    response = await call_next(request)
-    structlog.contextvars.clear_contextvars()
-    return response
 
+def _headers_to_dict(raw_headers: list[tuple[bytes, bytes]]) -> dict[str, str]:
+    return {k.decode("latin-1").lower(): v.decode("latin-1") for k, v in (raw_headers or [])}
 
-class FastAPIRequestContextMiddleware(BaseHTTPMiddleware):
-    """Middleware class for FastAPI using BaseHTTPMiddleware."""
 
-    async def dispatch(self, request: Request, call_next):
-        return await add_request_context_fastapi(request, call_next)
+def _sanitize_headers(headers: dict[str, str]) -> dict[str, str]:
+    out: dict[str, str] = {}
+    for k, v in (headers or {}).items():
+        lk = k.lower()
+        if lk == "authorization":
+            # Preserve scheme (e.g., "Bearer ***" or "Basic ***")
+            parts = v.split(" ", 1)
+            if len(parts) == 2:
+                out[k] = f"{parts[0]} ***"
+            else:
+                out[k] = "***"
+        elif lk in SENSITIVE_HEADERS:
+            out[k] = "<redacted>"
+        else:
+            out[k] = v
+    return out
+
+
+def _client_ip(scope: Scope, headers: dict[str, str]) -> Optional[str]:
+    xff = headers.get("x-forwarded-for")
+    if xff:
+        return xff.split(",")[0].strip()
+    client = scope.get("client")
+    return client[0] if client else None
+
+
+def _safe_int(value: Optional[str], default: int = 0) -> int:
+    try:
+        if value is None:
+            return default
+        v = int(value)
+        return v if v >= 0 else default
+    except Exception:
+        return default
+
+
+class RequestLoggingMiddleware:
+    """Lightweight ASGI middleware that logs each HTTP request/response.
+
+    - Uses structured logging with structlog
+    - Avoids reading request/response bodies (logs sizes instead)
+    - Distinguishes 2xx/3xx (info) vs 4xx (warning) vs 5xx (error)
+    - For errors, includes sanitized headers and traceback when exceptions occur
+    - Optionally propagates request_id to response headers
+    """
+
+    def __init__(
+        self,
+        app,
+        logger: Optional[structlog.BoundLoggerBase] = None,
+        slow_request_threshold_ms: Optional[int] = None,
+        propagate_request_id: bool = True,
+        skip_paths: Optional[set[str]] = None,
+        skip_prefixes: Optional[tuple[str, ...]] = None,
+        sample_2xx_rate: Optional[float] = None,
+    ) -> None:
+        self.app = app
+        self.logger = logger or structlog.get_logger("http")
+        self.slow_request_threshold_ms = slow_request_threshold_ms
+        self.propagate_request_id = propagate_request_id
+        self.skip_paths = skip_paths or {"/healthz", "/metrics"}
+        self.skip_prefixes = skip_prefixes or ("/metrics",)
+        self.sample_2xx_rate = sample_2xx_rate
+
+    async def __call__(self, scope: Scope, receive: Receive, send: Send) -> None:
+        if scope.get("type") != "http":
+            await self.app(scope, receive, send)
+            return
+
+        headers_raw: list[tuple[bytes, bytes]] = scope.get("headers") or []
+        req_headers = _headers_to_dict(headers_raw)
+
+        orig_traceparent = req_headers.get("traceparent")
+        request_id = (
+            orig_traceparent
+            or req_headers.get("x-request-id")
+            or req_headers.get("x-amzn-trace-id")
+            or str(uuid.uuid4())
+        )
+        method = scope.get("method", "UNKNOWN")
+        path = scope.get("path", "")
+        query_string = (scope.get("query_string") or b"").decode("latin-1")
+
+        # Bind core request context for correlation
+        structlog.contextvars.bind_contextvars(request_id=request_id, request_method=method, request_path=path)
+
+        client_ip = _client_ip(scope, req_headers)
+        user_agent = req_headers.get("user-agent")
+        req_content_length = _safe_int(req_headers.get("content-length"))
+        req_content_type = req_headers.get("content-type")
+
+        start = perf_counter()
+        resp: dict[str, Any] = {"status": None, "headers": [], "size": 0, "content_type": None}
+
+        async def send_wrapper(message: Message) -> None:
+            if message["type"] == "http.response.start":
+                resp["status"] = message.get("status")
+                hdrs = list(message.get("headers") or [])
+                resp["headers"] = hdrs
+                rh = _headers_to_dict(hdrs)
+                resp["content_type"] = rh.get("content-type")
+                if self.propagate_request_id:
+                    names = {k.lower() for k, _ in hdrs}
+                    if b"x-request-id" not in names:
+                        hdrs.append((b"x-request-id", request_id.encode("latin-1")))
+                        message["headers"] = hdrs
+                    if orig_traceparent and b"traceparent" not in names:
+                        hdrs.append((b"traceparent", orig_traceparent.encode("latin-1")))
+                        message["headers"] = hdrs
+            elif message["type"] == "http.response.body":
+                body = message.get("body") or b""
+                resp["size"] += len(body)
+            await send(message)
+
+        log = self.logger.bind()
+
+        # Skip noisy paths entirely (health/metrics) and OPTIONS requests; also skip configured prefixes
+        skip_logging = (
+            method == "OPTIONS" or (path in self.skip_paths) or any(path.startswith(p) for p in self.skip_prefixes)
+        )
+        if not skip_logging:
+            log.info(
+                "request.start",
+                request_id=request_id,
+                method=method,
+                path=path,
+                query=query_string,
+                client_ip=client_ip,
+                user_agent=user_agent,
+                req_content_length=req_content_length,
+                req_content_type=req_content_type,
+            )
+
+        try:
+            await self.app(scope, receive, send_wrapper)
+        except Exception:
+            duration_ms = int((perf_counter() - start) * 1000)
+            # Log with traceback for unexpected exceptions
+            log.error(
+                "request.exception",
+                request_id=request_id,
+                method=method,
+                path=path,
+                query=query_string,
+                client_ip=client_ip,
+                user_agent=user_agent,
+                duration_ms=duration_ms,
+                req_content_length=req_content_length,
+                req_content_type=req_content_type,
+                status_code=500,
+                response_size=resp["size"],
+                exc_info=True,
+                request_headers=_sanitize_headers(req_headers),
+            )
+            # Ensure context is cleared even when exceptions occur
+            structlog.contextvars.clear_contextvars()
+            raise
+
+        duration_ms = int((perf_counter() - start) * 1000)
+        status = int(resp["status"] or 200)
+
+        # Sampling for successful responses
+        sampled_ok = True
+        if status < 400 and self.sample_2xx_rate is not None:
+            try:
+                import random
+
+                sampled_ok = random.random() < max(0.0, min(1.0, float(self.sample_2xx_rate)))
+            except Exception:
+                sampled_ok = True
+
+        is_slow = self.slow_request_threshold_ms is not None and duration_ms >= self.slow_request_threshold_ms
+
+        level = "info"
+        if status >= 500:  # noqa: PLR2004
+            level = "error"
+        elif status >= 400 or (  # noqa: PLR2004
+            self.slow_request_threshold_ms is not None and duration_ms >= self.slow_request_threshold_ms
+        ):
+            level = "warning"
+
+        log_kwargs: dict[str, Any] = {
+            "request_id": request_id,
+            "method": method,
+            "path": path,
+            "query": query_string,
+            "client_ip": client_ip,
+            "user_agent": user_agent,
+            "status_code": status,
+            "duration_ms": duration_ms,
+            "response_size": int(resp["size"]),
+            "response_content_type": resp["content_type"],
+            "req_content_length": req_content_length,
+            "req_content_type": req_content_type,
+            "slow_request": is_slow,
+            "slow_threshold_ms": self.slow_request_threshold_ms,
+        }
+        if status >= 400:  # noqa: PLR2004
+            log_kwargs["request_headers"] = _sanitize_headers(req_headers)
+            log_kwargs["response_headers"] = _sanitize_headers(_headers_to_dict(resp["headers"]))
+
+        if not skip_logging:
+            if level == "error":
+                log.error("request.end", **log_kwargs)
+            elif level == "warning":
+                log.warning("request.end", **log_kwargs)
+            elif sampled_ok:
+                log.info("request.end", **log_kwargs)
+
+        structlog.contextvars.clear_contextvars()

ganicas_package-0.1.4.dist-info/METADATA

@@ -1,228 +0,0 @@
-Metadata-Version: 2.1
-Name: ganicas-package
-Version: 0.1.4
-Summary: Ganicas internal Python package for structured logging and utilities.
-Keywords: logging,utilities,internal-package
-Author: Ganicas
-Requires-Python: >=3.11,<4.0
-Classifier: Development Status :: 2 - Pre-Alpha
-Classifier: Intended Audience :: Developers
-Classifier: License :: Other/Proprietary License
-Classifier: Natural Language :: English
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.11
-Classifier: Programming Language :: Python :: 3.12
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.8
-Classifier: Programming Language :: Python :: 3.9
-Requires-Dist: fastapi (>=0.114.2,<0.116.0)
-Requires-Dist: flask (>=2.2.0,<3.0.0)
-Requires-Dist: httpx (>=0.28.1,<0.29.0)
-Requires-Dist: python-json-logger (>=3.2.1,<4.0.0)
-Requires-Dist: structlog (>=24.4.0,<25.0.0)
-Description-Content-Type: text/markdown
-
-# Ganicas Python Package
-
-### Structlog
-Structlog is a powerful logging library for structured, context-aware logging.
-More details can be found in the [structlog](https://www.structlog.org/en/stable/).
-
-#### Example, basic structlog configuration
-
-instead of `logger = logging.getLogger(__name__)` it is `logger = structlog.get_logger(__name__)`
-
-```python
-    from ganicas_utils.logging import LoggingConfigurator
-    from ganicas_utils.config import Config
-    import structlog
-
-    config = Config()
-
-    LoggingConfigurator(
-        service_name=config.APP_NAME,
-        log_level='INFO',
-        setup_logging_dict=True
-    ).configure_structlog(
-        formatter='plain_console',
-        formatter_std_lib='plain_console'
-    )
-
-    logger = structlog.get_logger(__name__)
-    logger.debug("This is a DEBUG log message", key_1="value_1", key_2="value_2", key_n="value_n")
-    logger.info("This is an INFO log message", key_1="value_1", key_2="value_2", key_n="value_n")
-    logger.warning("This is a WARNING log message", key_1="value_1", key_2="value_2", key_n="value_n")
-    logger.error("This is an ERROR log message", key_1="value_1", key_2="value_2", key_n="value_n")
-    logger.critical("This is a CRITICAL log message", key_1="value_1", key_2="value_2", key_n="value_n")
-
-    try:
-        1 / 0
-    except ZeroDivisionError:
-        logger.exception("An EXCEPTION log with stack trace occurred", key_1="value_1", key_2="value_2")
-
-
-```
-![basic example](images/plain_console_logger.png)
-
-
-In production, you should aim for structured, machine-readable logs that can be easily ingested by log aggregation and monitoring tools like ELK (Elasticsearch, Logstash, Kibana), Datadog, or Prometheus:
-
-```python
-    from ganicas_utils.logging import LoggingConfigurator
-    from ganicas_utils.config import Config
-    import structlog
-
-    config = Config()
-
-    LoggingConfigurator(
-        service_name=config.APP_NAME,
-        log_level='INFO',
-        setup_logging_dict=True
-    ).configure_structlog(
-        formatter='json_formatter',
-        formatter_std_lib='json_formatter'
-    )
-
-    logger = structlog.get_logger(__name__)
-    logger.debug("This is a DEBUG log message", key_1="value_1", key_2="value_2", key_n="value_n")
-    logger.info("This is an INFO log message", key_1="value_1", key_2="value_2", key_n="value_n")
-    logger.warning("This is a WARNING log message", key_1="value_1", key_2="value_2", key_n="value_n")
-    logger.error("This is an ERROR log message", key_1="value_1", key_2="value_2", key_n="value_n")
-    logger.critical("This is a CRITICAL log message", key_1="value_1", key_2="value_2", key_n="value_n")
-
-    try:
-        1 / 0
-    except ZeroDivisionError:
-        logger.exception("An EXCEPTION log with stack trace occurred", key_1="value_1", key_2="value_2")
-```
-
-![logger with different keys](images/json_logger.png)
-
-
-#### Using Middleware for Automatic Logging Context:
-
-The middleware adds request_id, IP, and user_id to every log during a request/response cycle.
-This middleware module provides logging context management for both Flask and FastAPI applications using structlog.
-
-Flask Middleware (add_request_context_flask): Captures essential request data such as the request ID, method, and path, binding them to the structlog context for better traceability during the request lifecycle.
-
-FastAPI Middleware (add_request_context_fastapi): Captures similar request metadata, ensuring a request ID is present, generating one if absent.
-It binds the request context to structlog and clears it after the request completes.
-
-Class-Based Middleware (FastAPIRequestContextMiddleware): A reusable FastAPI middleware class that integrates with the BaseHTTPMiddleware and delegates the logging setup to the add_request_context_fastapi function.
-
-This setup ensures structured, consistent logging across both frameworks, improving traceability and debugging in distributed systems.
-
-
-This guide explains how to set up and use structlog for structured logging in a Flask application. The goal is to have a consistent and centralized logging setup that can be reused across the application.
-The logger is initialized once in the main application file (e.g., app.py).
-
-```python
-    import sys
-    import uuid
-    from flask import Flask, request
-    from ganicas_utils.logging import LoggingConfigurator
-    from ganicas_utils.logging.middlewares import add_request_context_flask
-    from ganicas_utils.config import Config
-    import structlog
-
-    config = Config()
-
-    LoggingConfigurator(
-        service_name=config.APP_NAME,
-        log_level="INFO",
-        setup_logging_dict=True,
-    ).configure_structlog(formatter='json_formatter', formatter_std_lib='json_formatter')
-
-    logger = structlog.get_logger(__name__)
-
-    app = Flask(__name__)
-
-    @app.before_request
-    def set_logging_context():
-        """Bind context for each request using the middleware."""
-        add_request_context_flask()
-        logger.info("Context set for request")
-
-    with app.test_client() as client:
-        dynamic_request_id = str(uuid.uuid4())
-        client.get("/", headers={"X-User-Name": "John Doe", "X-Request-ID": dynamic_request_id})
-        logger.info("Test client request sent", request_id=dynamic_request_id)
-
-```
-
-![logger with context flask](images/flask_logger_with_context.png)
-
-You can use the same logger instance across different modules by importing structlog directly.
-Example (services.py):
-
-
-```python
-    import structlog
-
-    logger = structlog.get_logger(__name__)
-    logger.info("Processing data started", data_size=100)
-```
-Key Points:
-
-- Centralized Configuration: The logger is initialized once in app.py.
-- Consistent Usage: structlog.get_logger(__name__) is imported and used across all files.
-- Context Management: Context is managed using structlog.contextvars.bind_contextvars().
-- Structured Logging: The JSON formatter ensures logs are machine-readable.
-
-FastAPI:
-
-```python
-    import uuid
-    from fastapi import FastAPI, Request
-    from ganicas_utils.logging.middlewares import FastAPIRequestContextMiddleware
-    import structlog
-
-    config = Config()
-
-    LoggingConfigurator(
-        service_name=config.APP_NAME,
-        log_level="INFO",
-        setup_logging_dict=True,
-    ).configure_structlog(formatter='json_formatter', formatter_std_lib='json_formatter')
-
-    logger = structlog.get_logger(__name__)
-    app = FastAPI()
-    app.add_middleware(FastAPIRequestContextMiddleware)
-
-```
-![logger with context fastapi](images/fastapi_logger_with_context.png)
-
-
-Automatic injection of:
--   user_id
--   IP
--   request_id
--  request_method
-
-
-This a console view, in prod it will be json (using python json logging to have standard logging and structlog logging as close as possible)
-
-
-### Why Use a Structured Logger?
--   Standard logging often outputs plain text logs, which can be challenging for log aggregation tools like EFK Stack or Grafana Loki to process effectively.
--   Structured logging outputs data in a machine-readable format (e.g., JSON), making it easier for log analysis tools to filter and process logs efficiently.
--   With structured logging, developers can filter logs by fields such as request_id, user_id, and transaction_id for better traceability across distributed systems.
--   The primary goal is to simplify debugging, enable better error tracking, and improve observability with enhanced log analysis capabilities.
--   Structured logs are designed to be consumed primarily by machines for monitoring and analytics, while still being readable for developers when needed.
--   This package leverages structlog, a library that enhances Python's standard logging by providing better context management and a flexible structure for log messages.
-
-
-# Development of this project
-
-Please install [poetry](https://python-poetry.org/docs/#installation) as this is the tool we use for releasing and development.
-
-    poetry install && poetry run pytest -rs --cov=ganicas_utils -s
-
-To run tests inside docker:
-
-    poetry install --with dev && poetry run pytest -rs --cov=ganicas_utils
-
-To run pre-commit:
-    poetry run pre-commit run --all-files
-