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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: json-logify
-Version: 0.1.0
+Version: 0.1.2
 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.2.dist-info/RECORD

@@ -0,0 +1,11 @@
+json_logify-0.1.2.dist-info/licenses/LICENSE,sha256=qRyWd6Y0_db_j_ECsAAEJW8-XMnhYUg_yK3c5UkOfNI,1077
+logify/__init__.py,sha256=t2Jjw7T4jRMIYvXJOTBraaW6MneifmS_gDKDlrRHmeU,1053
+logify/core.py,sha256=Th9JXajJ1ciX1DEcMH88412-CMyIpYMCGIw1h2zeLq4,10249
+logify/django.py,sha256=X5S8lG3yow13XI-GAHC2tT7WRg-yjXcdRwip03GZOR8,14816
+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.2.dist-info/METADATA,sha256=ZZQVSFVGb2ZSgEcdMDVfxTdBypXXKAcBIKdewCRKnYA,11563
+json_logify-0.1.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+json_logify-0.1.2.dist-info/top_level.txt,sha256=MRERkeaav8J-KtwGpiLDCnSNQ5e2JqKUMAlJnYVntao,7
+json_logify-0.1.2.dist-info/RECORD,,

logify/core.py

@@ -21,6 +21,125 @@ def orjson_serializer(_, __, event_dict):
     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."""
+    # Get max length from global settings only
+    max_length = 100
+    try:
+        from .django import _get_setting
+
+        max_length = _get_setting("LOGIFY_MAX_STRING_LENGTH", 100)
+    except ImportError:
+        # Use default if django module not available
+        pass
+
+    # 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."""
+    # Get settings for string length limits
+    max_length = 100
+    try:
+        from .django import _get_setting
+
+        max_length = _get_setting("LOGIFY_MAX_STRING_LENGTH", 100)
+    except ImportError:
+        pass
+
+    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."""
+    # Default sensitive fields
+    default_sensitive = [
+        "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",
+    ]
+
+    # Get sensitive fields from global settings only
+    sensitive_fields = default_sensitive
+    try:
+        from .django import _get_setting
+
+        sensitive_fields = _get_setting("LOGIFY_SENSITIVE_FIELDS", default_sensitive)
+    except ImportError:
+        # Use defaults if django module not available
+        pass
+
+    # Convert to set of lowercase strings
+    if isinstance(sensitive_fields, (list, tuple)):
+        sensitive_fields = set(field.lower() for field in sensitive_fields)
+    elif isinstance(sensitive_fields, set):
+        sensitive_fields = set(field.lower() for field in sensitive_fields)
+    else:
+        sensitive_fields = set(field.lower() for field in default_sensitive)
+
+    def _mask_recursive(obj):
+        """Recursively mask sensitive fields in dicts and lists."""
+        if isinstance(obj, dict):
+            masked = {}
+            for k, v in obj.items():
+                key_lower = k.lower()
+                # Check if key contains any sensitive substring
+                if any(s in key_lower for s in sensitive_fields):
+                    if v and str(v).strip():
+                        masked[k] = "***"
+                    else:
+                        masked[k] = v
+                else:
+                    masked[k] = _mask_recursive(v)
+            return masked
+        elif isinstance(obj, list):
+            return [_mask_recursive(item) for item in 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 +158,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 +173,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 +194,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 +236,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,10 +253,10 @@ 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"):
@@ -138,6 +268,9 @@ def configure_logging(service_name: str = "app", level: str = "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 +280,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,102 @@
 Django integration for json-logify structured logging.
 """
 
+import logging
+
+import structlog
+
 from .core import clear_request_context, configure_logging, generate_request_id, set_request_context
 
+# Global settings storage for when Django settings are not available
+_global_settings = {}
+
+
+def _set_global_setting(key: str, value):
+    """Set a global setting value."""
+    _global_settings[key] = value
 
-def get_logging_config(service_name: str = "django", level: str = "INFO", json_logs: bool = True):
+
+def _get_setting(key: str, default=None):
+    """Get setting value from global settings only."""
+    # Return value from global settings (set by get_logging_config parameters)
+    return _global_settings.get(key, default)
+
+
+def get_logging_config(
+    service_name: str = "django",
+    level: str = "INFO",
+    json_logs: bool = True,
+    excluded_fields: list = None,
+    sensitive_fields: list = None,
+    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)
+        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"],
+            max_string_length=200,
+            ignore_paths=["/health/", "/static/"]
+        )
     """
     if json_logs:
         configure_logging(service_name=service_name, level=level)
 
+    # Store settings globally for the processors to use
+    _set_global_setting("SERVICE_NAME", service_name)
+    if excluded_fields is not None:
+        _set_global_setting("LOGIFY_EXCLUDED_FIELDS", excluded_fields)
+    if sensitive_fields is not None:
+        _set_global_setting("LOGIFY_SENSITIVE_FIELDS", sensitive_fields)
+    if max_string_length is not None:
+        _set_global_setting("LOGIFY_MAX_STRING_LENGTH", max_string_length)
+    if ignore_paths is not None:
+        _set_global_setting("LOGIFY_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 +112,329 @@ 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)
+
+        # Import here to avoid circular imports
+        from .core import info
+
         # Generate request ID and set context
         request_id = generate_request_id()
         request.logify_request_id = request_id
 
-        set_request_context(
+        # Get service name from global settings or use default
+        service_name = _get_setting("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 - core processors will handle)
+        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 (no scrubbing)
+            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."""
+        # Get ignore paths from global settings
+        default_ignore_paths = ["/health/", "/healthz/", "/api/schema/", "/static/", "/favicon.ico", "/robots.txt"]
+
+        try:
+            ignore_paths = _get_setting("LOGIFY_IGNORE_PATHS", default_ignore_paths)
+        except Exception:
+            ignore_paths = default_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 which will be used for headers too
+        default_sensitive = [
+            "password",
+            "passwd",
+            "pass",
+            "pwd",
+            "secret",
+            "token",
+            "key",
+            "api_key",
+            "access_token",
+            "refresh_token",
+            "auth_token",
+            "session_key",
+            "private_key",
+            "authorization",
+            "cookie",
+            "x-api-key",
+            "x-auth-token",
+            "x-csrf-token",
+        ]
+
+        try:
+            sensitive_fields = _get_setting("LOGIFY_SENSITIVE_FIELDS", default_sensitive)
+        except Exception:
+            sensitive_fields = default_sensitive
+
+        if isinstance(sensitive_fields, (list, tuple)):
+            sensitive_fields = set(field.lower() for field in sensitive_fields)
+        else:
+            sensitive_fields = set(field.lower() for field in default_sensitive)
+
+        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 (no scrubbing - core processors will handle)."""
+        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
+
+                request_body = json.loads(body_bytes.decode("utf-8"))
+                return request_body
+            else:
+                # 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)
+                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 (no scrubbing - core processors will handle)."""
+        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
+
+                response_body = json.loads(body_bytes.decode("utf-8"))
+                return response_body
+            else:
+                # 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 json-logify structlog
     configure_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
+        default_excluded = [
+            "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",
+            # Add Django-specific problematic fields
+            "request",
+            "response",
+            "server_time",
+            "status_code",
+        ]
+
+        excluded_fields = _get_setting("LOGIFY_EXCLUDED_FIELDS", default_excluded)
+        if isinstance(excluded_fields, (list, tuple)):
+            excluded_fields = set(excluded_fields)
+        elif not isinstance(excluded_fields, set):
+            excluded_fields = set(default_excluded)
+
+        # Get sensitive fields from settings
+        default_sensitive = [
+            "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",
+        ]
+        sensitive_fields = _get_setting("LOGIFY_SENSITIVE_FIELDS", default_sensitive)
+        if isinstance(sensitive_fields, (list, tuple)):
+            sensitive_fields = set(field.lower() for field in sensitive_fields)
+        elif not isinstance(sensitive_fields, set):
+            sensitive_fields = set(field.lower() for field in default_sensitive)
+
+        # Extract extra fields, excluding specified fields and masking sensitive ones
+        extra = {}
+        for key, value in record.__dict__.items():
+            if key not in excluded_fields:
+                # Skip complex objects that can't be JSON serialized
+                if hasattr(value, "__dict__") and not isinstance(value, (str, int, float, bool, list, dict)):
+                    continue
+
+                # Mask sensitive fields
+                if key.lower() in sensitive_fields:
+                    if value and str(value).strip():
+                        extra[key] = "***"
+                    else:
+                        extra[key] = value
+                else:
+                    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,,