miso-client 0.1.0__py3-none-any.whl → 3.7.2__py3-none-any.whl

miso_client/utils/http_error_handler.py

@@ -0,0 +1,92 @@
+"""
+HTTP error handler utilities for InternalHttpClient.
+
+This module provides error parsing and handling functionality for HTTP responses.
+"""
+
+from typing import Optional
+
+import httpx
+
+from ..models.error_response import ErrorResponse
+
+
+def extract_correlation_id_from_response(
+    response: Optional[httpx.Response] = None,
+) -> Optional[str]:
+    """
+    Extract correlation ID from response headers.
+
+    Checks common correlation ID header names.
+
+    Args:
+        response: HTTP response object (optional)
+
+    Returns:
+        Correlation ID string if found, None otherwise
+    """
+    if not response:
+        return None
+
+    # Check common correlation ID header names (case-insensitive)
+    correlation_headers = [
+        "x-correlation-id",
+        "x-request-id",
+        "correlation-id",
+        "correlationId",
+        "x-correlationid",
+        "request-id",
+    ]
+
+    for header_name in correlation_headers:
+        correlation_id = response.headers.get(header_name) or response.headers.get(
+            header_name.lower()
+        )
+        if correlation_id:
+            return str(correlation_id)
+
+    return None
+
+
+def parse_error_response(response: httpx.Response, url: str) -> Optional[ErrorResponse]:
+    """
+    Parse structured error response from HTTP response.
+
+    Extracts correlation ID from response headers if not present in response body.
+
+    Args:
+        response: HTTP response object
+        url: Request URL (used for instance URI if not in response)
+
+    Returns:
+        ErrorResponse if response matches structure, None otherwise
+    """
+    if not response.headers.get("content-type", "").startswith("application/json"):
+        return None
+
+    try:
+        response_data = response.json()
+        # Check if response matches ErrorResponse structure
+        if (
+            isinstance(response_data, dict)
+            and "errors" in response_data
+            and "type" in response_data
+            and "title" in response_data
+            and "statusCode" in response_data
+        ):
+            # Set instance from URL if not provided
+            if "instance" not in response_data or not response_data["instance"]:
+                response_data["instance"] = url
+
+            # Extract correlation ID from headers if not present in response body
+            if "correlationId" not in response_data or not response_data["correlationId"]:
+                correlation_id = extract_correlation_id_from_response(response)
+                if correlation_id:
+                    response_data["correlationId"] = correlation_id
+
+            return ErrorResponse(**response_data)
+    except (ValueError, TypeError, KeyError):
+        # JSON parsing failed or structure doesn't match
+        pass
+
+    return None

miso_client/utils/http_log_formatter.py

@@ -0,0 +1,115 @@
+"""
+HTTP log formatting utilities for ISO 27001 compliant audit and debug logging.
+
+This module provides formatting functions for building audit and debug log contexts.
+All sensitive data should be masked before passing to these formatters.
+"""
+
+from typing import Any, Dict, Optional
+
+
+def _add_optional_fields(context: Dict[str, Any], **fields: Any) -> None:
+    """
+    Add optional fields to context dictionary if they are not None.
+
+    Args:
+        context: Context dictionary to add fields to
+        **fields: Optional fields to add (value is None if field should be skipped)
+    """
+    for key, value in fields.items():
+        if value is not None:
+            context[key] = value
+
+
+def build_audit_context(
+    method: str,
+    url: str,
+    status_code: Optional[int],
+    duration_ms: int,
+    user_id: Optional[str],
+    request_size: Optional[int],
+    response_size: Optional[int],
+    error_message: Optional[str],
+    correlation_id: Optional[str] = None,
+) -> Dict[str, Any]:
+    """
+    Build audit context dictionary for logging.
+
+    Args:
+        method: HTTP method
+        url: Request URL
+        status_code: HTTP status code
+        duration_ms: Request duration in milliseconds
+        user_id: User ID if available
+        request_size: Request size in bytes (optional)
+        response_size: Response size in bytes (optional)
+        error_message: Error message if request failed (optional)
+        correlation_id: Correlation ID if available (optional)
+
+    Returns:
+        Audit context dictionary
+    """
+    audit_context: Dict[str, Any] = {
+        "method": method,
+        "url": url,
+        "statusCode": status_code,
+        "duration": duration_ms,
+    }
+    _add_optional_fields(
+        audit_context,
+        userId=user_id,
+        requestSize=request_size,
+        responseSize=response_size,
+        error=error_message,
+        correlationId=correlation_id,
+    )
+    return audit_context
+
+
+def build_debug_context(
+    method: str,
+    url: str,
+    status_code: Optional[int],
+    duration_ms: int,
+    base_url: str,
+    user_id: Optional[str],
+    masked_headers: Optional[Dict[str, Any]],
+    masked_body: Optional[Any],
+    masked_response: Optional[str],
+    query_params: Optional[Dict[str, Any]],
+) -> Dict[str, Any]:
+    """
+    Build debug context dictionary for detailed logging.
+
+    Args:
+        method: HTTP method
+        url: Request URL
+        status_code: HTTP status code
+        duration_ms: Request duration in milliseconds
+        base_url: Base URL from config
+        user_id: User ID if available
+        masked_headers: Masked request headers
+        masked_body: Masked request body
+        masked_response: Masked response body
+        query_params: Masked query parameters
+
+    Returns:
+        Debug context dictionary
+    """
+    debug_context: Dict[str, Any] = {
+        "method": method,
+        "url": url,
+        "statusCode": status_code,
+        "duration": duration_ms,
+        "baseURL": base_url,
+        "timeout": 30.0,  # Default timeout
+    }
+    _add_optional_fields(
+        debug_context,
+        userId=user_id,
+        requestHeaders=masked_headers,
+        requestBody=masked_body,
+        responseBody=masked_response,
+        queryParams=query_params,
+    )
+    return debug_context

miso_client/utils/http_log_masker.py

@@ -0,0 +1,203 @@
+"""
+HTTP log data masking utilities for ISO 27001 compliant logging.
+
+This module provides data masking functions specifically for HTTP request/response
+logging. All sensitive data is masked using DataMasker before logging.
+"""
+
+from typing import Any, Dict, Optional
+from urllib.parse import parse_qs, urlparse
+
+from .data_masker import DataMasker
+
+
+def mask_error_message(error: Exception) -> Optional[str]:
+    """
+    Mask sensitive data in error message.
+
+    Args:
+        error: Exception object
+
+    Returns:
+        Masked error message string, or None if no error
+    """
+    if error is None:
+        return None
+
+    try:
+        error_message = str(error)
+        # Mask if error message contains sensitive keywords
+        if isinstance(error_message, str) and any(
+            keyword in error_message.lower() for keyword in ["password", "token", "secret", "key"]
+        ):
+            return DataMasker.MASKED_VALUE
+        return error_message
+    except Exception:
+        return None
+
+
+def mask_request_data(
+    request_headers: Optional[Dict[str, Any]], request_data: Optional[Dict[str, Any]]
+) -> tuple[Optional[Dict[str, Any]], Optional[Any]]:
+    """
+    Mask sensitive data in request headers and body.
+
+    Args:
+        request_headers: Request headers dictionary
+        request_data: Request body data
+
+    Returns:
+        Tuple of (masked_headers, masked_body)
+    """
+    masked_headers: Optional[Dict[str, Any]] = None
+    if request_headers:
+        masked_headers = DataMasker.mask_sensitive_data(request_headers)
+
+    masked_body: Optional[Any] = None
+    if request_data is not None:
+        masked_body = DataMasker.mask_sensitive_data(request_data)
+
+    return masked_headers, masked_body
+
+
+def extract_and_mask_query_params(url: str) -> Optional[Dict[str, Any]]:
+    """
+    Extract query parameters from URL and mask sensitive data.
+
+    Args:
+        url: Request URL with query string
+
+    Returns:
+        Masked query parameters dictionary, or None if no query params
+    """
+    try:
+        parsed_url = urlparse(url)
+        if not parsed_url.query:
+            return None
+
+        query_dict = parse_qs(parsed_url.query)
+        # Convert lists to single values for simplicity
+        query_simple: Dict[str, Any] = {
+            k: v[0] if len(v) == 1 else v for k, v in query_dict.items()
+        }
+        masked = DataMasker.mask_sensitive_data(query_simple)
+        return masked if isinstance(masked, dict) else None
+    except Exception:
+        return None
+
+
+def estimate_object_size(obj: Any) -> int:
+    """
+    Quick size estimation without full JSON serialization.
+
+    Args:
+        obj: Object to estimate size for
+
+    Returns:
+        Estimated size in bytes
+    """
+    if obj is None:
+        return 0
+
+    if isinstance(obj, str):
+        return len(obj.encode("utf-8"))
+
+    if not isinstance(obj, (dict, list)):
+        return 10  # Estimate for primitives
+
+    if isinstance(obj, list):
+        if len(obj) == 0:
+            return 10
+        # Sample first few items for estimation
+        sample_size = min(3, len(obj))
+        estimated_item_size = sum(estimate_object_size(item) for item in obj[:sample_size])
+        avg_item_size = estimated_item_size / sample_size if sample_size > 0 else 100
+        return int(len(obj) * avg_item_size)
+
+    # Object: estimate based on property count and values
+    size = 0
+    for key, value in obj.items():
+        size += len(str(key).encode("utf-8")) + estimate_object_size(value)
+    return size
+
+
+def truncate_response_body(body: Any, max_size: int = 10000) -> tuple[Any, bool]:
+    """
+    Truncate response body to reduce processing cost.
+
+    Args:
+        body: Response body to truncate
+        max_size: Maximum size in bytes
+
+    Returns:
+        Tuple of (truncated_data, was_truncated)
+    """
+    if body is None:
+        return body, False
+
+    # For strings, truncate directly
+    if isinstance(body, str):
+        body_bytes = body.encode("utf-8")
+        if len(body_bytes) <= max_size:
+            return body, False
+        truncated = body_bytes[:max_size].decode("utf-8", errors="ignore") + "..."
+        return truncated, True
+
+    # For objects/arrays, estimate size first
+    estimated_size = estimate_object_size(body)
+    if estimated_size <= max_size:
+        return body, False
+
+    # If estimated size is too large, return placeholder
+    return {
+        "_message": "Response body too large, truncated for performance",
+        "_estimatedSize": estimated_size,
+    }, True
+
+
+def mask_response_data(
+    response: Optional[Any], max_size: Optional[int] = None, max_masking_size: Optional[int] = None
+) -> Optional[str]:
+    """
+    Mask sensitive data in response body and limit size.
+
+    Args:
+        response: Response data
+        max_size: Maximum size before truncation (default: 10000)
+        max_masking_size: Maximum size before skipping masking (default: 50000)
+
+    Returns:
+        Masked response body as string, or None
+    """
+    if response is None:
+        return None
+
+    max_size = max_size or 10000
+    max_masking_size = max_masking_size or 50000
+
+    try:
+        # Check if we should skip masking due to size
+        estimated_size = estimate_object_size(response)
+        if estimated_size > max_masking_size:
+            return str({" _message": "Response body too large, masking skipped"})
+
+        # Truncate if needed
+        truncated_body, was_truncated = truncate_response_body(response, max_size)
+
+        # Mask sensitive data
+        try:
+            if isinstance(truncated_body, dict):
+                masked_dict = DataMasker.mask_sensitive_data(truncated_body)
+                result = str(masked_dict)
+                if was_truncated and len(result) > 1000:
+                    result = result[:1000] + "..."
+                return result
+            elif isinstance(truncated_body, str):
+                # Already truncated string
+                return truncated_body
+            else:
+                return str(truncated_body)
+        except Exception:
+            return str(truncated_body) if was_truncated else str(response)
+    except Exception:
+        return None