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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: json-logify
-Version: 0.1.2
+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>

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.2.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,6 +15,62 @@ 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."""
@@ -23,15 +79,7 @@ def orjson_serializer(_, __, event_dict):
 
 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
+    max_length = _config["MAX_STRING_LENGTH"]
 
     # Truncate long strings - only if max_length is positive
     if max_length > 0:
@@ -44,14 +92,7 @@ def truncate_long_strings(_, __, 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
+    max_length = _config["MAX_STRING_LENGTH"]
 
     cleaned = {}
     for key, value in event_dict.items():
@@ -75,63 +116,78 @@ def clean_non_serializable_objects(_, __, event_dict):
 
 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 = _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)
 
-        sensitive_fields = _get_setting("LOGIFY_SENSITIVE_FIELDS", default_sensitive)
-    except ImportError:
-        # Use defaults if django module not available
-        pass
+            if modified:
+                return "&".join(new_parts)
 
-    # 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)
+        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():
-                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:
+                # 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)
@@ -259,10 +315,23 @@ def get_logger(name: str = "json-logify"):
     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))
 

logify/django.py

@@ -6,21 +6,43 @@ 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_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)
+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(
@@ -29,6 +51,7 @@ def get_logging_config(
     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,
 ):
@@ -41,6 +64,7 @@ def get_logging_config(
         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
 
@@ -51,23 +75,31 @@ def get_logging_config(
             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
 
-    # 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)
+        default_excluded = _django_settings["EXCLUDED_FIELDS"]
+        _django_settings["EXCLUDED_FIELDS"] = set(default_excluded) | set(excluded_fields)
+
     if ignore_paths is not None:
-        _set_global_setting("LOGIFY_IGNORE_PATHS", ignore_paths)
+        _django_settings["IGNORE_PATHS"] = ignore_paths
 
     return {
         "version": 1,
@@ -116,15 +148,12 @@ class LogifyMiddleware:
         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
 
-        # Get service name from global settings or use default
-        service_name = _get_setting("SERVICE_NAME", "django-app")
+        # Get service name
+        service_name = _django_settings.get("SERVICE_NAME", "django-app")
 
         # Get user info
         user_info = self._get_user_info(request)
@@ -132,7 +161,7 @@ class LogifyMiddleware:
         # Get and scrub headers
         scrubbed_headers = self._scrub_headers(dict(request.headers))
 
-        # Get request body (no scrubbing - core processors will handle)
+        # 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
@@ -154,7 +183,7 @@ class LogifyMiddleware:
         try:
             response = self.get_response(request)
 
-            # Get response body with content type filtering (no scrubbing)
+            # Get response body with content type filtering
             response_body = self._get_response_body(response)
 
             # Log request completion with response info
@@ -173,13 +202,7 @@ class LogifyMiddleware:
 
     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
+        ignore_paths = _django_settings.get("IGNORE_PATHS", [])
 
         if isinstance(ignore_paths, (list, tuple)):
             for ignore_path in ignore_paths:
@@ -195,37 +218,13 @@ class LogifyMiddleware:
 
     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
+        # Get sensitive fields from core config
+        sensitive_fields = get_config_value("SENSITIVE_FIELDS")
 
-        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)
+        # 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():
@@ -238,7 +237,7 @@ class LogifyMiddleware:
         return scrubbed
 
     def _get_request_body(self, request):
-        """Get request body with size limits (no scrubbing - core processors will handle)."""
+        """Get request body with size limits."""
         if not request.body:
             return None
 
@@ -249,27 +248,32 @@ class LogifyMiddleware:
             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]
+                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 (no scrubbing - core processors will handle)."""
+        """Get response body with content type filtering."""
         if not hasattr(response, "content") or not response.content:
             return None
 
@@ -298,11 +302,14 @@ class LogifyMiddleware:
             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]
+                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>"
@@ -314,7 +321,7 @@ def setup_django_logging(service_name: str = "django"):
     Call this in your Django settings or apps.py
     """
     # Configure json-logify structlog
-    configure_logging(service_name=service_name)
+    configure_core_logging(service_name=service_name)
 
     # Configure structlog to intercept standard logging
     structlog.configure(
@@ -349,85 +356,19 @@ class StructlogHandler(logging.Handler):
         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)
+        excluded_fields = _django_settings.get("EXCLUDED_FIELDS", set())
 
-        # Extract extra fields, excluding specified fields and masking sensitive ones
+        # 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
 
-                # 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
+                extra[key] = value
 
         # Log with structlog
         structlog_method(

json_logify-0.1.2.dist-info/RECORD

@@ -1,11 +0,0 @@
-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,,