json-logify 0.1.0__py3-none-any.whl → 0.1.3__py3-none-any.whl

{json_logify-0.1.0.dist-info → json_logify-0.1.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: json-logify
-Version: 0.1.0
+Version: 0.1.3
 Summary: Universal structured logging with exact JSON schema for Python frameworks
 Author-email: Bakdoolot Kulbarakov <kulbarakovbh@gmail.com>
 Maintainer-email: Bakdoolot Kulbarakov <kulbarakovbh@gmail.com>
@@ -54,11 +54,6 @@ Requires-Dist: structlog>=23.0.0
 Requires-Dist: orjson>=3.8.0
 Provides-Extra: django
 Requires-Dist: django>=5.2.6; extra == "django"
-Provides-Extra: fastapi
-Requires-Dist: fastapi>=0.116.1; extra == "fastapi"
-Requires-Dist: uvicorn>=0.35.0; extra == "fastapi"
-Provides-Extra: flask
-Requires-Dist: flask>=3.1.2; extra == "flask"
 Provides-Extra: dev
 Requires-Dist: pytest>=8.4.2; extra == "dev"
 Requires-Dist: pytest-cov>=4.0.0; extra == "dev"
@@ -83,13 +78,14 @@ Universal structured logging with exact JSON schema for Python frameworks.
 
 ## Features
 
-- <� **Exact JSON Schema**: Consistent log format across all frameworks
-- � **High Performance**: Built with structlog and orjson for maximum speed
-- < **Universal**: Works with Django, FastAPI, Flask, and standalone Python
-- =' **Easy Setup**: One-line configuration for most use cases
-- =� **Rich Context**: Request IDs, user tracking, and custom payload support
-- =
- **Modern Python**: Full type hints and async support
+- **Exact JSON Schema**: Consistent log format across all frameworks
+- **High Performance**: Built with structlog and orjson for maximum speed
+- **Universal**: Works with Django, FastAPI, Flask and standalone Python
+- **Security First**: Automatic masking of sensitive data (passwords, tokens, etc.)
+- **Easy Setup**: One-line configuration for most use cases
+- **Rich Context**: Request IDs, user tracking, and custom payload support
+- **Smart Filtering**: Configurable path ignoring and request/response body logging
+- **Modern Python**: Full type hints and async support
 
 ## Quick Start
 
@@ -101,8 +97,8 @@ pip install json-logify
 
 # For specific frameworks
 pip install json-logify[django]
-pip install json-logify[fastapi]
-pip install json-logify[flask]
+# pip install json-logify[fastapi]  # Coming soon
+# pip install json-logify[flask]    # Coming soon
 
 # Everything
 pip install json-logify[all]
@@ -111,50 +107,164 @@ pip install json-logify[all]
 ### Basic Usage
 
 ```python
-from logify import info, error
+from logify import info, error, debug, warning
 
-# Simple logging
-info("User logged in", user_id="12345", action="login")
+# Basic logging with message
+info("User logged in")
 
-# Error logging with exception
+# With structured context
+info("Payment processed", amount=100.0, currency="USD", user_id="user123")
+
+# Different log levels
+debug("Debug information", query_time=0.023)
+warning("Slow database query detected", query_time=1.52, query_id="a1b2c3")
+error("Payment failed", error_code="CARD_DECLINED", user_id="user123")
+
+# Exception handling
 try:
-    raise ValueError("Something went wrong")
+    # Some code that might fail
+    result = some_function()
 except Exception as e:
-    error("Operation failed", error=e, operation="data_processing")
+    error("Operation failed", exception=str(e), operation="some_function")
 ```
 
-Output:
-```json
-{
-  "timestamp": "2025-01-15T10:30:00.123Z",
-  "message": "User logged in",
-  "level": "INFO",
-  "payload": {
-    "user_id": "12345",
-    "action": "login"
-  }
-}
+### Django Integration
+
+#### 1. Install with Django extras:
+
+```bash
+pip install json-logify[django]
 ```
 
-### Django Integration
+#### 2. Configure in settings.py:
 
 ```python
-# settings.py
 from logify.django import get_logging_config
 
-LOGGING = get_logging_config(
-    service_name="myapp",
-    json_logs=True
-)
-
-# Add middleware (optional for request tracking)
+# Add middleware to MIDDLEWARE list
 MIDDLEWARE = [
-    'logify.django.LogifyMiddleware',
     # ... other middleware
+    'logify.django.LogifyMiddleware',  # ← Add this
 ]
+
+# Configure logging with json-logify
+LOGGING = get_logging_config(
+    service_name="my-django-app",
+    level="INFO",
+    max_string_length=200,              # String truncation limit
+    sensitive_fields=[                  # Fields to mask with "***"
+        "password", "passwd", "secret", "token", "api_key",
+        "access_token", "refresh_token", "session_key",
+        "credit_card", "cvv", "ssn", "authorization",
+        "cookie", "x-api-key", "custom_sensitive_field"
+    ],
+    ignore_paths=[                      # Paths to skip logging
+        "/health/", "/static/", "/favicon.ico",
+        "/admin/jsi18n/", "/metrics/"
+    ]
+)
+
+# Optional: Reduce Django built-in logger noise
+LOGGING['loggers'].update({
+    'django.utils.autoreload': {'level': 'WARNING'},
+    'django.db.backends': {'level': 'WARNING'},
+    'django.server': {'level': 'WARNING'},
+    'django.request': {'level': 'WARNING'},
+})
 ```
 
-### FastAPI Integration
+#### 3. Use in your views:
+
+```python
+from logify import info, error, debug, warning
+from django.http import JsonResponse
+
+def process_payment(request):
+    # Log with automatic request context
+    info("Payment processing started",
+         user_id=request.user.id,
+         amount=request.POST.get('amount'))
+
+    try:
+        # Sensitive data gets automatically masked
+        info("User data received",
+             username=request.user.username,    # ← Visible
+             password=request.POST.get('password'),  # ← Masked: "***"
+             credit_card=request.POST.get('card'),   # ← Masked: "***"
+             email=request.user.email)               # ← Visible
+
+        # Your business logic
+        payment = process_payment_logic(request.POST)
+
+        # Log success
+        info("Payment completed",
+             payment_id=payment.id,
+             status="success",
+             amount=payment.amount)
+
+        return JsonResponse({"status": "success", "payment_id": payment.id})
+
+    except ValidationError as e:
+        error("Payment validation failed", error=e, user_id=request.user.id)
+        return JsonResponse({"status": "error", "message": str(e)}, status=400)
+    except Exception as e:
+        error("Payment processing failed", error=e)
+        return JsonResponse({"status": "error"}, status=500)
+```
+
+#### 4. What you get automatically:
+
+**Request logging:**
+```json
+{
+  "timestamp": "2025-09-09T08:09:35.933Z",
+  "message": "Request started",
+  "level": "INFO",
+  "payload": {
+    "request_id": "b62e59b6-bae7-4a96-821d",
+    "service": "my-django-app",
+    "method": "POST",
+    "path": "/api/payment/",
+    "user_info": "User ID: 123: john_doe",
+    "headers": {
+      "Content-Type": "application/json",
+      "Authorization": "***",           // ← Automatically masked
+      "User-Agent": "curl/8.7.1"
+    },
+    "request_body": {
+      "username": "john_doe",
+      "password": "***",                // ← Automatically masked
+      "credit_card": "***"              // ← Automatically masked
+    }
+  }
+}
+```
+
+**Your application logs:**
+```json
+{
+  "timestamp": "2025-09-09T08:09:35.934Z",
+  "message": "Payment completed",
+  "level": "INFO",
+  "payload": {
+    "request_id": "b62e59b6-bae7-4a96-821d",  // ← Auto-linked to request
+    "payment_id": "pay_123456",
+    "status": "success",
+    "amount": 99.99
+  }
+}
+```
+
+**🔒 Security Features:**
+- **Automatic masking**: Passwords, tokens, API keys, credit cards → `"***"`
+- **Header filtering**: Authorization, Cookie, X-API-Key → `"***"`
+- **Recursive masking**: Works in nested objects and arrays
+- **Request/Response body**: Limited size + content-type filtering
+- **Path ignoring**: Skip health checks, static files, etc.
+- Request and response bodies (with sensitive fields masked)
+
+<!--
+### FastAPI Integration (Coming Soon)
 
 ```python
 from fastapi import FastAPI
@@ -170,7 +280,7 @@ async def root():
     return {"message": "Hello World"}
 ```
 
-### Flask Integration
+### Flask Integration (Coming Soon)
 
 ```python
 from flask import Flask
@@ -185,6 +295,7 @@ def hello():
     info("Flask endpoint called", endpoint="/")
     return "Hello, World!"
 ```
+-->
 
 ## Advanced Usage
 

json_logify-0.1.3.dist-info/RECORD

@@ -0,0 +1,11 @@
+json_logify-0.1.3.dist-info/licenses/LICENSE,sha256=qRyWd6Y0_db_j_ECsAAEJW8-XMnhYUg_yK3c5UkOfNI,1077
+logify/__init__.py,sha256=t2Jjw7T4jRMIYvXJOTBraaW6MneifmS_gDKDlrRHmeU,1053
+logify/core.py,sha256=6IoiwnIOlghiCPE89lyAG_FK4II9bhyvZRlK75UJ_F8,12603
+logify/django.py,sha256=qy20qkJhhUPz0Nl3yQMPryqVj5H0RXE2DxPk7La6iws,12842
+logify/fastapi.py,sha256=G570BPDdgEv2e0gASI2SZqNjyUNeIyemPcCXH6f-UPg,2710
+logify/flask.py,sha256=TCWBSni8uEWBjvNJTFM87VPUwDRI3PTdAm3HSbP5R2g,2802
+logify/version.py,sha256=YvuYzWnKtqBb-IqG8HAu-nhIYAsgj9Vmc_b9o7vO-js,22
+json_logify-0.1.3.dist-info/METADATA,sha256=ZAxBK34k_XY-G64m6uSFn5isgO-VwUa3RKWi2BpFkOs,11563
+json_logify-0.1.3.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+json_logify-0.1.3.dist-info/top_level.txt,sha256=MRERkeaav8J-KtwGpiLDCnSNQ5e2JqKUMAlJnYVntao,7
+json_logify-0.1.3.dist-info/RECORD,,

{json_logify-0.1.0.dist-info → json_logify-0.1.3.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.9.0)
+Generator: setuptools (80.10.2)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

logify/core.py

@@ -15,12 +15,187 @@ import structlog
 # Context variables for request tracking
 _request_context: ContextVar[Dict[str, Any]] = ContextVar("request_context", default={})
 
+# Internal configuration storage
+_config = {
+    "MAX_STRING_LENGTH": 100,
+    "SENSITIVE_FIELDS": {
+        "password",
+        "passwd",
+        "pass",
+        "pwd",
+        "secret",
+        "token",
+        "key",
+        "api_key",
+        "access_token",
+        "refresh_token",
+        "auth_token",
+        "session_key",
+        "private_key",
+        "credit_card",
+        "card_number",
+        "cvv",
+        "ssn",
+        "social_security_number",
+    },
+}
+
+
+def configure_core(sensitive_fields=None, replace_sensitive_defaults=False, max_string_length=None):
+    """
+    Configure core logging settings.
+
+    Args:
+        sensitive_fields: List or set of field names to mask
+        replace_sensitive_defaults: If True, replace default sensitive fields with provided ones.
+                                  If False, merge provided fields with defaults.
+        max_string_length: Maximum length for string truncation
+    """
+    if sensitive_fields is not None:
+        new_fields = set()
+        if isinstance(sensitive_fields, (list, tuple)):
+            new_fields = set(field.lower() for field in sensitive_fields)
+        elif isinstance(sensitive_fields, set):
+            new_fields = set(field.lower() for field in sensitive_fields)
+
+        if replace_sensitive_defaults:
+            _config["SENSITIVE_FIELDS"] = new_fields
+        else:
+            _config["SENSITIVE_FIELDS"].update(new_fields)
+
+    if max_string_length is not None:
+        _config["MAX_STRING_LENGTH"] = max_string_length
+
+
+def get_config_value(key: str, default=None):
+    """Get a value from core configuration."""
+    return _config.get(key, default)
+
 
 def orjson_serializer(_, __, event_dict):
     """Serialize log entries using orjson for performance."""
     return orjson.dumps(event_dict).decode("utf-8")
 
 
+def truncate_long_strings(_, __, event_dict):
+    """Truncate long strings in log entries based on max_string_length setting."""
+    max_length = _config["MAX_STRING_LENGTH"]
+
+    # Truncate long strings - only if max_length is positive
+    if max_length > 0:
+        for key, value in event_dict.items():
+            if isinstance(value, str) and len(value) > max_length:
+                event_dict[key] = value[:max_length] + "..."
+
+    return event_dict
+
+
+def clean_non_serializable_objects(_, __, event_dict):
+    """Clean non-serializable objects from log entries."""
+    max_length = _config["MAX_STRING_LENGTH"]
+
+    cleaned = {}
+    for key, value in event_dict.items():
+        # Skip 'error' field - it will be handled specially in format_log_entry
+        if key == "error":
+            cleaned[key] = value
+            continue
+
+        try:
+            # Test if value is JSON serializable
+            orjson.dumps(value)
+            cleaned[key] = value
+        except TypeError:
+            # Convert non-serializable objects to their string representation
+            if hasattr(value, "__class__"):
+                cleaned[key] = f"<{value.__class__.__name__}: {str(value)[:max_length]}>"
+            else:
+                cleaned[key] = str(value)[:max_length]
+    return cleaned
+
+
+def mask_sensitive_fields(_, __, event_dict):
+    """Mask sensitive fields in log entries recursively."""
+    sensitive_fields = _config["SENSITIVE_FIELDS"]
+
+    def _mask_value_if_sensitive(key, value):
+        """Check if key is sensitive and return masked value if so."""
+        key_lower = key.lower()
+        if any(s in key_lower for s in sensitive_fields):
+            if value and str(value).strip():
+                return "***"
+        return value
+
+    def _scrub_string(text):
+        """Scrub sensitive data from strings (e.g. url encoded bodies, query strings)."""
+        if not text:
+            return text
+
+        # Handle URLs with query parameters
+        if "?" in text:
+            base, query = text.split("?", 1)
+            # Recursively scrub the query part
+            scrubbed_query = _scrub_string(query)
+            return f"{base}?{scrubbed_query}"
+
+        # pattern matching for key=value pairs where key is sensitive
+        # We do a simple approach: split by & and =
+        if "=" in text:
+            # Check if this looks like a query string or form data
+            # This is a heuristic
+            parts = text.split("&")
+            new_parts = []
+            modified = False
+
+            for part in parts:
+                if "=" in part:
+                    k, v = part.split("=", 1)
+                    # Check if key is sensitive
+                    k_lower = k.lower()
+                    if any(s in k_lower for s in sensitive_fields):
+                        new_parts.append(f"{k}=***")
+                        modified = True
+                    else:
+                        new_parts.append(part)
+                else:
+                    new_parts.append(part)
+
+            if modified:
+                return "&".join(new_parts)
+
+        return text
+
+    def _mask_recursive(obj):
+        """Recursively mask sensitive fields in dicts and lists."""
+        if isinstance(obj, dict):
+            masked = {}
+            for k, v in obj.items():
+                # First check if the key itself is sensitive
+                v_masked = _mask_value_if_sensitive(k, v)
+                if v_masked == "***":
+                    masked[k] = "***"
+                    continue
+
+                # If not masked by key, recurse or string scrub
+                if isinstance(v, (dict, list)):
+                    masked[k] = _mask_recursive(v)
+                elif isinstance(v, str):
+                    masked[k] = _scrub_string(v)
+                else:
+                    masked[k] = v
+            return masked
+        elif isinstance(obj, list):
+            return [_mask_recursive(item) for item in obj]
+        elif isinstance(obj, str):
+            return _scrub_string(obj)
+        return obj
+
+    # Apply masking to the entire event_dict (including top-level keys)
+    event_dict = _mask_recursive(event_dict)
+
+    return event_dict
+
+
 def add_timestamp(_, __, event_dict):
     """Add ISO timestamp to log entries."""
     # Unresolved attribute reference 'UTC' for class 'datetime'
@@ -39,11 +214,12 @@ def format_log_entry(logger, name, event_dict):
     # Remove level from event_dict to avoid duplication
     event_dict.pop("level", None)
 
-    # Get context
+    # Get only request_id from context to avoid duplication
     try:
         context = _request_context.get({})
+        request_id_only = {"request_id": context.get("request_id")} if context.get("request_id") else {}
     except LookupError:
-        context = {}
+        request_id_only = {}
 
     # Extract error from event_dict if present
     error_field = event_dict.pop("error", None)
@@ -53,12 +229,19 @@ def format_log_entry(logger, name, event_dict):
         "timestamp": event_dict.pop("timestamp", datetime.now(UTC).isoformat().replace("+00:00", "Z")),
         "message": message,
         "level": level.upper(),
-        "payload": {**context, **event_dict},
+        "payload": {**request_id_only, **event_dict},
     }
 
     # Add optional error field at top level
     if error_field:
-        formatted_entry["error"] = str(error_field)
+        # Format as "ErrorType: message"
+        if isinstance(error_field, Exception):
+            if error_field.args:
+                formatted_entry["error"] = f"{error_field.__class__.__name__}: {error_field.args[0]}"
+            else:
+                formatted_entry["error"] = f"{error_field.__class__.__name__}: No message"
+        else:
+            formatted_entry["error"] = str(error_field)
 
     return formatted_entry
 
@@ -67,6 +250,9 @@ def format_log_entry(logger, name, event_dict):
 structlog.configure(
     processors=[
         structlog.stdlib.add_log_level,
+        clean_non_serializable_objects,  # Clean non-serializable objects FIRST
+        truncate_long_strings,  # Truncate long strings SECOND
+        mask_sensitive_fields,  # Mask sensitive fields THIRD
         add_timestamp,
         format_log_entry,
         orjson_serializer,
@@ -106,7 +292,7 @@ def error(message: str, error: Exception = None, **kwargs):
     """Log error message."""
     if error:
         kwargs["error"] = error  # Will be moved to top-level by format_log_entry
-        kwargs["error_type"] = type(error).__name__
+        # error_type removed - now included in error field as "Type: message"
     logger.error(message, **kwargs)
 
 
@@ -123,21 +309,37 @@ def exception(message: str, **kwargs):
     logger.error(message, **kwargs)
 
 
-def get_logger(name: str = "json-logify", service: str = "app"):
+def get_logger(name: str = "json-logify"):
     """Get a named logger instance."""
     bound_logger = structlog.get_logger(name)
-    return bound_logger.bind(service=service)
+    return bound_logger
 
 
-def configure_logging(service_name: str = "app", level: str = "INFO"):
+def configure_logging(
+    service_name: str = "app",
+    level: str = "INFO",
+    sensitive_fields=None,
+    replace_sensitive_defaults=False,
+    max_string_length=None,
+):
     """Configure logging for the application."""
     import logging
 
+    # Configure core settings
+    configure_core(
+        sensitive_fields=sensitive_fields,
+        replace_sensitive_defaults=replace_sensitive_defaults,
+        max_string_length=max_string_length,
+    )
+
     # Set logging level on stdlib logger
     logging.basicConfig(level=getattr(logging, level.upper(), logging.INFO))
 
     structlog.configure(
         processors=[
+            clean_non_serializable_objects,  # Clean non-serializable objects FIRST
+            truncate_long_strings,  # Truncate long strings SECOND
+            mask_sensitive_fields,  # Mask sensitive fields THIRD
             add_timestamp,
             format_log_entry,
             orjson_serializer,
@@ -147,9 +349,9 @@ def configure_logging(service_name: str = "app", level: str = "INFO"):
         cache_logger_on_first_use=True,
     )
 
-    # Bind service name to the default logger
+    # Set default logger without service binding
     global logger
-    logger = structlog.get_logger("json-logify").bind(service=service_name)
+    logger = structlog.get_logger("json-logify")
 
 
 def bind(**kwargs):

logify/django.py

@@ -2,44 +2,134 @@
 Django integration for json-logify structured logging.
 """
 
-from .core import clear_request_context, configure_logging, generate_request_id, set_request_context
+import logging
 
+import structlog
 
-def get_logging_config(service_name: str = "django", level: str = "INFO", json_logs: bool = True):
+from .core import clear_request_context, configure_core
+from .core import configure_logging as configure_core_logging
+from .core import generate_request_id, get_config_value, info, set_request_context
+
+# Django-specific settings storage
+_django_settings = {
+    "SERVICE_NAME": "django",
+    "IGNORE_PATHS": ["/health/", "/healthz/", "/api/schema/", "/static/", "/favicon.ico", "/robots.txt"],
+    "EXCLUDED_FIELDS": {
+        "name",
+        "msg",
+        "args",
+        "levelname",
+        "levelno",
+        "pathname",
+        "filename",
+        "module",
+        "lineno",
+        "funcName",
+        "created",
+        "msecs",
+        "relativeCreated",
+        "thread",
+        "threadName",
+        "processName",
+        "process",
+        "message",
+        "exc_info",
+        "exc_text",
+        "stack_info",
+        "getMessage",
+        "request",
+        "response",
+        "server_time",
+        "status_code",
+    },
+}
+
+
+def get_logging_config(
+    service_name: str = "django",
+    level: str = "INFO",
+    json_logs: bool = True,
+    excluded_fields: list = None,
+    sensitive_fields: list = None,
+    replace_sensitive_defaults: bool = False,
+    max_string_length: int = None,
+    ignore_paths: list = None,
+):
     """
     Get Django logging configuration for json-logify.
 
+    Args:
+        service_name: Name of the service for logging
+        level: Logging level (DEBUG, INFO, WARNING, ERROR)
+        json_logs: Whether to enable JSON logging
+        excluded_fields: List of fields to exclude from logs
+        sensitive_fields: List of fields to mask with *** (also used for sensitive headers)
+        replace_sensitive_defaults: If True, replace default sensitive fields. If False, merge.
+        max_string_length: Maximum length for string truncation
+        ignore_paths: List of URL paths to ignore from logging
+
     Usage in settings.py:
         from logify.django import get_logging_config
-        LOGGING = get_logging_config(service_name="myapp")
+        LOGGING = get_logging_config(
+            service_name="myapp",
+            level="INFO",
+            excluded_fields=["custom_field"],
+            sensitive_fields=["password", "secret", "authorization"],
+            replace_sensitive_defaults=False, # Optional, defaults to False (merge)
+            max_string_length=200,
+            ignore_paths=["/health/", "/static/"]
+        )
     """
+    # Configure core settings (this sets global state in core module)
+    configure_core(
+        sensitive_fields=sensitive_fields,
+        replace_sensitive_defaults=replace_sensitive_defaults,
+        max_string_length=max_string_length,
+    )
+
     if json_logs:
-        configure_logging(service_name=service_name, level=level)
+        # This sets up the structlog pipeline
+        configure_core_logging(service_name=service_name, level=level)
+
+    # Store Django-specific settings
+    _django_settings["SERVICE_NAME"] = service_name
+
+    if excluded_fields is not None:
+        default_excluded = _django_settings["EXCLUDED_FIELDS"]
+        _django_settings["EXCLUDED_FIELDS"] = set(default_excluded) | set(excluded_fields)
+
+    if ignore_paths is not None:
+        _django_settings["IGNORE_PATHS"] = ignore_paths
 
     return {
         "version": 1,
         "disable_existing_loggers": False,
         "formatters": {
-            "json": {"format": "%(message)s"},
+            "json": {
+                "format": "%(asctime)s %(name)s %(levelname)s %(message)s",
+            },
         },
         "handlers": {
             "console": {
                 "class": "logging.StreamHandler",
                 "formatter": "json",
             },
+            "structlog": {
+                "()": "logify.django.StructlogHandler",
+            },
         },
         "root": {
-            "handlers": ["console"],
+            "handlers": ["structlog"],
             "level": level,
         },
         "loggers": {
             "django": {
-                "handlers": ["console"],
+                "handlers": ["structlog"],
                 "level": level,
                 "propagate": False,
             },
             service_name: {
-                "handlers": ["console"],
+                "handlers": ["structlog"],
                 "level": level,
                 "propagate": False,
             },
@@ -54,35 +144,238 @@ class LogifyMiddleware:
         self.get_response = get_response
 
     def __call__(self, request):
+        # Skip logging for ignored paths
+        if self._should_ignore_path(request.path):
+            return self.get_response(request)
+
         # Generate request ID and set context
         request_id = generate_request_id()
         request.logify_request_id = request_id
 
-        set_request_context(
+        # Get service name
+        service_name = _django_settings.get("SERVICE_NAME", "django-app")
+
+        # Get user info
+        user_info = self._get_user_info(request)
+
+        # Get and scrub headers
+        scrubbed_headers = self._scrub_headers(dict(request.headers))
+
+        # Get request body (no scrubbing needed here - core processors will handle masking)
+        request_body = self._get_request_body(request)
+
+        # Log request start with all context information ONCE
+        info(
+            "Request started",
             request_id=request_id,
+            service=service_name,
             method=request.method,
             path=request.path,
-            user_agent=request.META.get("HTTP_USER_AGENT", ""),
-            remote_addr=request.META.get("REMOTE_ADDR", ""),
+            user_info=user_info,
+            headers=scrubbed_headers,
+            query_params=dict(request.GET) if request.GET else None,
+            request_body=request_body,
         )
 
+        # Set minimal context for other logs (only request_id)
+        set_request_context(request_id=request_id)
+
         try:
             response = self.get_response(request)
 
-            # Add response info to context
-            set_request_context(
+            # Get response body with content type filtering
+            response_body = self._get_response_body(response)
+
+            # Log request completion with response info
+            info(
+                "Request completed",
+                request_id=request_id,
+                user_info=user_info,
                 status_code=response.status_code,
                 content_length=len(response.content) if hasattr(response, "content") else None,
+                response_body=response_body,
             )
 
             return response
         finally:
             clear_request_context()
 
+    def _should_ignore_path(self, path):
+        """Check if path should be ignored from logging."""
+        ignore_paths = _django_settings.get("IGNORE_PATHS", [])
+
+        if isinstance(ignore_paths, (list, tuple)):
+            for ignore_path in ignore_paths:
+                if path.startswith(ignore_path):
+                    return True
+        return False
+
+    def _get_user_info(self, request):
+        """Get user information from request."""
+        if hasattr(request, "user") and request.user.is_authenticated:
+            return f"User ID: {request.user.id}: {request.user.username}"
+        return "Anonymous user"
+
+    def _scrub_headers(self, headers):
+        """Mask sensitive headers using sensitive_fields settings."""
+        # Get sensitive fields from core config
+        sensitive_fields = get_config_value("SENSITIVE_FIELDS")
+
+        # We need to manually scrub here because headers are a dict we are constructing to pass to log
+        # And we want to label filtered headers specifically as [FILTERED] sometimes, or just use core logic.
+        # But core logic turns things into "***".
+        # Let's align with core logic.
+
+        scrubbed = {}
+        for key, value in headers.items():
+            key_lower = key.lower().replace("-", "_")  # Convert dashes to underscores for matching
+            # Check if header name contains any sensitive substring
+            if any(s in key_lower for s in sensitive_fields):
+                scrubbed[key] = "[FILTERED]"
+            else:
+                scrubbed[key] = value
+        return scrubbed
+
+    def _get_request_body(self, request):
+        """Get request body with size limits."""
+        if not request.body:
+            return None
+
+        try:
+            # Limit body size for logging (max 10KB)
+            body_bytes = request.body[:10240]
+
+            if request.content_type and "json" in request.content_type:
+                import json
+
+                try:
+                    request_body = json.loads(body_bytes.decode("utf-8"))
+                    return request_body
+                except Exception:
+                    # Fallback if JSON parse fails
+                    pass
+
+            # For non-JSON data, try to parse as form data
+            if request.method in ["POST", "PUT", "PATCH"]:
+                try:
+                    # Try form data first
+                    form_data = dict(request.POST)
+                    if form_data:
+                        return form_data
+                except Exception:
+                    pass
+
+            # Fall back to raw string (truncated)
+            # The CORE processor will mask sensitive data in this string!
+            return body_bytes.decode("utf-8", errors="replace")[:1000]
+
+        except Exception:
+            return "<non-readable body>"
+
+    def _get_response_body(self, response):
+        """Get response body with content type filtering."""
+        if not hasattr(response, "content") or not response.content:
+            return None
+
+        content_type = response.get("Content-Type", "") if hasattr(response, "get") else ""
+
+        # Skip HTML, JavaScript, CSS, and other non-data content types
+        skip_content_types = [
+            "text/html",
+            "text/css",
+            "application/javascript",
+            "text/javascript",
+            "image/",
+            "video/",
+            "audio/",
+            "application/pdf",
+            "application/octet-stream",
+        ]
+
+        if any(skip_type in content_type for skip_type in skip_content_types):
+            return f"<skipped: {content_type}>"
+
+        try:
+            # Limit response body size for logging (max 10KB)
+            body_bytes = response.content[:10240]
+
+            if "json" in content_type:
+                import json
+
+                try:
+                    response_body = json.loads(body_bytes.decode("utf-8"))
+                    return response_body
+                except Exception:
+                    pass
+
+            # For non-JSON responses, return truncated text
+            return body_bytes.decode("utf-8", errors="replace")[:1000]
+
+        except Exception:
+            return "<non-readable body>"
+
 
 def setup_django_logging(service_name: str = "django"):
     """
     Set up Django logging with json-logify.
     Call this in your Django settings or apps.py
     """
-    configure_logging(service_name=service_name)
+    # Configure json-logify structlog
+    configure_core_logging(service_name=service_name)
+
+    # Configure structlog to intercept standard logging
+    structlog.configure(
+        processors=[
+            structlog.stdlib.filter_by_level,
+            structlog.stdlib.add_logger_name,
+            structlog.stdlib.add_log_level,
+            structlog.stdlib.PositionalArgumentsFormatter(),
+            structlog.processors.TimeStamper(fmt="iso"),
+            structlog.processors.StackInfoRenderer(),
+            structlog.processors.format_exc_info,
+            structlog.processors.UnicodeDecoder(),
+            structlog.processors.JSONRenderer(),
+        ],
+        context_class=dict,
+        logger_factory=structlog.stdlib.LoggerFactory(),
+        wrapper_class=structlog.stdlib.BoundLogger,
+        cache_logger_on_first_use=True,
+    )
+
+
+class StructlogHandler(logging.Handler):
+    """Custom handler that routes standard logging to structlog."""
+
+    def __init__(self):
+        super().__init__()
+        self.structlog_logger = structlog.get_logger()
+
+    def emit(self, record):
+        # Convert logging record to structlog format
+        level_name = record.levelname.lower()
+        structlog_method = getattr(self.structlog_logger, level_name, self.structlog_logger.info)
+
+        # Get excluded fields from settings
+        excluded_fields = _django_settings.get("EXCLUDED_FIELDS", set())
+
+        # Extract extra fields, excluding specified fields
+        # Note: We rely on core processors to mask sensitive data!
+        extra = {}
+        for key, value in record.__dict__.items():
+            if key not in excluded_fields:
+                # Skip complex objects that can't be JSON serialized
+                # Core has a cleaner which handles this too, but we can filtering here for safety
+                if hasattr(value, "__dict__") and not isinstance(value, (str, int, float, bool, list, dict)):
+                    continue
+
+                extra[key] = value
+
+        # Log with structlog
+        structlog_method(
+            record.getMessage(),
+            logger=record.name,
+            module=record.module,
+            funcName=record.funcName,
+            lineno=record.lineno,
+            **extra,
+        )

logify/fastapi.py

@@ -1,82 +1,82 @@
-"""
-FastAPI integration for json-logify structured logging.
-"""
-
-import time
-
-from fastapi import Request
-from starlette.middleware.base import BaseHTTPMiddleware
-
-from .core import clear_request_context, configure_logging, error, generate_request_id, info, set_request_context
-
-
-class LogifyMiddleware(BaseHTTPMiddleware):
-    """FastAPI middleware for structured logging with request context."""
-
-    def __init__(self, app, service_name: str = "fastapi", log_requests: bool = True):
-        super().__init__(app)
-        self.service_name = service_name
-        self.log_requests = log_requests
-        configure_logging(service_name=service_name)
-
-    async def dispatch(self, request: Request, call_next):
-        # Generate request ID and set context
-        request_id = generate_request_id()
-        start_time = time.time()
-
-        # Extract client info
-        client_host = getattr(request.client, "host", "unknown") if request.client else "unknown"
-
-        set_request_context(
-            request_id=request_id,
-            method=request.method,
-            path=request.url.path,
-            query_params=str(request.query_params) if request.query_params else None,
-            client_host=client_host,
-            user_agent=request.headers.get("user-agent", ""),
-        )
-
-        if self.log_requests:
-            info("Request started", method=request.method, path=request.url.path, request_id=request_id)
-
-        try:
-            response = await call_next(request)
-
-            duration = time.time() - start_time
-
-            # Add response info to context
-            set_request_context(status_code=response.status_code, duration_seconds=duration)
-
-            if self.log_requests:
-                info(
-                    "Request completed",
-                    status_code=response.status_code,
-                    duration_seconds=duration,
-                    request_id=request_id,
-                )
-
-            return response
-
-        except Exception as e:
-            duration = time.time() - start_time
-
-            if self.log_requests:
-                error(
-                    "Request failed",
-                    error=e,
-                    duration_seconds=duration,
-                    request_id=request_id,
-                )
-
-            raise
-
-        finally:
-            clear_request_context()
-
-
-def setup_fastapi_logging(service_name: str = "fastapi"):
-    """
-    Set up FastAPI logging with json-logify.
-    Call this when creating your FastAPI app.
-    """
-    configure_logging(service_name=service_name)
+# """
+# FastAPI integration for json-logify structured logging.
+# """
+#
+# import time
+#
+# from fastapi import Request
+# from starlette.middleware.base import BaseHTTPMiddleware
+#
+# from .core import clear_request_context, configure_logging, error, generate_request_id, info, set_request_context
+#
+#
+# class LogifyMiddleware(BaseHTTPMiddleware):
+#     """FastAPI middleware for structured logging with request context."""
+#
+#     def __init__(self, app, service_name: str = "fastapi", log_requests: bool = True):
+#         super().__init__(app)
+#         self.service_name = service_name
+#         self.log_requests = log_requests
+#         configure_logging(service_name=service_name)
+#
+#     async def dispatch(self, request: Request, call_next):
+#         # Generate request ID and set context
+#         request_id = generate_request_id()
+#         start_time = time.time()
+#
+#         # Extract client info
+#         client_host = getattr(request.client, "host", "unknown") if request.client else "unknown"
+#
+#         set_request_context(
+#             request_id=request_id,
+#             method=request.method,
+#             path=request.url.path,
+#             query_params=str(request.query_params) if request.query_params else None,
+#             client_host=client_host,
+#             user_agent=request.headers.get("user-agent", ""),
+#         )
+#
+#         if self.log_requests:
+#             info("Request started", method=request.method, path=request.url.path, request_id=request_id)
+#
+#         try:
+#             response = await call_next(request)
+#
+#             duration = time.time() - start_time
+#
+#             # Add response info to context
+#             set_request_context(status_code=response.status_code, duration_seconds=duration)
+#
+#             if self.log_requests:
+#                 info(
+#                     "Request completed",
+#                     status_code=response.status_code,
+#                     duration_seconds=duration,
+#                     request_id=request_id,
+#                 )
+#
+#             return response
+#
+#         except Exception as e:
+#             duration = time.time() - start_time
+#
+#             if self.log_requests:
+#                 error(
+#                     "Request failed",
+#                     error=e,
+#                     duration_seconds=duration,
+#                     request_id=request_id,
+#                 )
+#
+#             raise
+#
+#         finally:
+#             clear_request_context()
+#
+#
+# def setup_fastapi_logging(service_name: str = "fastapi"):
+#     """
+#     Set up FastAPI logging with json-logify.
+#     Call this when creating your FastAPI app.
+#     """
+#     configure_logging(service_name=service_name)

logify/flask.py

@@ -1,88 +1,88 @@
-"""
-Flask integration for json-logify structured logging.
-"""
-
-import time
-
-from flask import Flask, g, request
-
-from .core import clear_request_context, configure_logging, error, generate_request_id, info, set_request_context
-
-
-def init_logify(app: Flask, service_name: str = "flask", log_requests: bool = True):
-    """
-    Initialize json-logify for Flask application.
-
-    Usage:
-        from flask import Flask
-        from logify.flask import init_logify
-
-        app = Flask(__name__)
-        init_logify(app, service_name="myapp")
-    """
-    configure_logging(service_name=service_name)
-
-    @app.before_request
-    def before_request():
-        # Generate request ID and set context
-        request_id = generate_request_id()
-        g.logify_request_id = request_id
-        g.logify_start_time = time.time()
-
-        set_request_context(
-            request_id=request_id,
-            method=request.method,
-            path=request.path,
-            query_string=request.query_string.decode() if request.query_string else None,
-            remote_addr=request.remote_addr,
-            user_agent=request.headers.get("User-Agent", ""),
-        )
-
-        if log_requests:
-            info("Request started", method=request.method, path=request.path, request_id=request_id)
-
-    @app.after_request
-    def after_request(response):
-        try:
-            # Calculate duration
-            duration = time.time() - g.logify_start_time
-
-            # Add response info to context
-            set_request_context(
-                status_code=response.status_code, duration_seconds=duration, content_length=response.content_length
-            )
-
-            if log_requests:
-                info(
-                    "Request completed",
-                    status_code=response.status_code,
-                    duration_seconds=duration,
-                    request_id=g.logify_request_id,
-                )
-        except Exception:
-            # If we can't access g, just return the response
-            pass
-
-        return response
-
-    def teardown_request(exception):
-        # Clear request context
-        clear_request_context()
-
-        if exception and log_requests:
-            error(
-                "Request failed",
-                error=exception,
-                request_id=getattr(g, "logify_request_id", "unknown"),
-            )
-
-    # Register teardown function
-    app.teardown_appcontext(teardown_request)
-
-
-def setup_flask_logging(service_name: str = "flask"):
-    """
-    Set up Flask logging with json-logify.
-    Call this when creating your Flask app.
-    """
-    configure_logging(service_name=service_name)
+# """
+# Flask integration for json-logify structured logging.
+# """
+#
+# import time
+#
+# from flask import Flask, g, request
+#
+# from .core import clear_request_context, configure_logging, error, generate_request_id, info, set_request_context
+#
+#
+# def init_logify(app: Flask, service_name: str = "flask", log_requests: bool = True):
+#     """
+#     Initialize json-logify for Flask application.
+#
+#     Usage:
+#         from flask import Flask
+#         from logify.flask import init_logify
+#
+#         app = Flask(__name__)
+#         init_logify(app, service_name="myapp")
+#     """
+#     configure_logging(service_name=service_name)
+#
+#     @app.before_request
+#     def before_request():
+#         # Generate request ID and set context
+#         request_id = generate_request_id()
+#         g.logify_request_id = request_id
+#         g.logify_start_time = time.time()
+#
+#         set_request_context(
+#             request_id=request_id,
+#             method=request.method,
+#             path=request.path,
+#             query_string=request.query_string.decode() if request.query_string else None,
+#             remote_addr=request.remote_addr,
+#             user_agent=request.headers.get("User-Agent", ""),
+#         )
+#
+#         if log_requests:
+#             info("Request started", method=request.method, path=request.path, request_id=request_id)
+#
+#     @app.after_request
+#     def after_request(response):
+#         try:
+#             # Calculate duration
+#             duration = time.time() - g.logify_start_time
+#
+#             # Add response info to context
+#             set_request_context(
+#                 status_code=response.status_code, duration_seconds=duration, content_length=response.content_length
+#             )
+#
+#             if log_requests:
+#                 info(
+#                     "Request completed",
+#                     status_code=response.status_code,
+#                     duration_seconds=duration,
+#                     request_id=g.logify_request_id,
+#                 )
+#         except Exception:
+#             # If we can't access g, just return the response
+#             pass
+#
+#         return response
+#
+#     def teardown_request(exception):
+#         # Clear request context
+#         clear_request_context()
+#
+#         if exception and log_requests:
+#             error(
+#                 "Request failed",
+#                 error=exception,
+#                 request_id=getattr(g, "logify_request_id", "unknown"),
+#             )
+#
+#     # Register teardown function
+#     app.teardown_appcontext(teardown_request)
+#
+#
+# def setup_flask_logging(service_name: str = "flask"):
+#     """
+#     Set up Flask logging with json-logify.
+#     Call this when creating your Flask app.
+#     """
+#     configure_logging(service_name=service_name)

logify/version.py

@@ -1 +1 @@
-__version__ = "0.1.0"
+__version__ = "0.1.2"

json_logify-0.1.0.dist-info/RECORD

@@ -1,11 +0,0 @@
-json_logify-0.1.0.dist-info/licenses/LICENSE,sha256=qRyWd6Y0_db_j_ECsAAEJW8-XMnhYUg_yK3c5UkOfNI,1077
-logify/__init__.py,sha256=t2Jjw7T4jRMIYvXJOTBraaW6MneifmS_gDKDlrRHmeU,1053
-logify/core.py,sha256=kiMraMhpH9GShY0lPhXAnBO0bTMe0a77cIVpWldecZY,5548
-logify/django.py,sha256=i5z9-nzrBF712ba1xkMpAsND-RLFopDLk8M7tsyTPzk,2526
-logify/fastapi.py,sha256=ACQPWGVfTexUUCQX2oh-s5NBT1q0q5UDARbNsKulamU,2567
-logify/flask.py,sha256=YPRsaFiojP-2buZCwNhm5JmpgBAakJAQsKy1hh6r8ek,2645
-logify/version.py,sha256=kUR5RAFc7HCeiqdlX36dZOHkUI5wI6V_43RpEcD8b-0,22
-json_logify-0.1.0.dist-info/METADATA,sha256=Lu5bw9vf8mz16MTG0jkOXmKltqX1osvMl8E03aXRR30,7659
-json_logify-0.1.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-json_logify-0.1.0.dist-info/top_level.txt,sha256=MRERkeaav8J-KtwGpiLDCnSNQ5e2JqKUMAlJnYVntao,7
-json_logify-0.1.0.dist-info/RECORD,,