logging-objects-with-schema 0.4.0__tar.gz → 1.0.0__tar.gz

{logging_objects_with_schema-0.4.0 → logging_objects_with_schema-1.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: logging-objects-with-schema
-Version: 0.4.0
+Version: 1.0.0
 Summary: Proxy logging wrapper that validates extra fields against a JSON schema.
 Keywords: logging,schema,validation,structured-logging,structured-logs
 Author: Dmitrii Safronov
@@ -8,7 +8,6 @@ Author-email: Dmitrii Safronov <dhameoelin+logging-objects-with-schema@gmail.com
 License-Expression: Apache-2.0
 License-File: LICENSE
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
@@ -17,9 +16,9 @@ Classifier: Programming Language :: Python :: 3 :: Only
 Classifier: Intended Audience :: Developers
 Classifier: Topic :: System :: Logging
 Classifier: Typing :: Typed
-Requires-Python: >=3.10
-Project-URL: Issues, https://github.com/disafronov/python-logging-objects-with-schema/issues
+Requires-Python: >=3.11
 Project-URL: Source, https://github.com/disafronov/python-logging-objects-with-schema
+Project-URL: Issues, https://github.com/disafronov/python-logging-objects-with-schema/issues
 Description-Content-Type: text/markdown
 
 # python-logging-objects-with-schema
@@ -52,6 +51,9 @@ systems) can rely on a consistent log structure.
   problem.
 - Any mismatch between runtime values and the declared types (wrong types,
   `None` values, disallowed list elements) is also treated as a data error.
+  Type checks use `type()`, not `isinstance()`: `bool` is **not** accepted
+  where `int` is declared, and `int` is **not** accepted where `float` is
+  declared. There are no implicit type conversions.
 - All validation problems are aggregated and logged as a single ERROR message
   **after** the log record has been emitted, ensuring 100% compatibility with
   standard logger behavior (no exceptions are raised).
@@ -169,7 +171,9 @@ directory until it finds the file or reaches the filesystem root.
 **Important**: If there are any problems with the schema (missing file, broken
 JSON, invalid structure, etc.), the application is terminated after logging
 schema problems to stderr. Schema validation happens when the first logger
-instance is created.
+instance is created. Termination uses `os._exit(1)` — bypassing `atexit`
+handlers and `finally` blocks — to prevent any cleanup code from running
+against a broken logger that was never fully registered.
 
 **Note**: The schema is compiled once per process and cached. Schema changes
 require an application restart to take effect. The library is thread-safe.
@@ -365,3 +369,5 @@ All keys are merged together - they are not replaced, only supplemented.
   keys are used, maintaining 100% backward compatibility
 - `None` and empty `set()` are semantically equivalent for `forbidden_keys` -
   both mean "no additional forbidden keys" and produce the same result
+
+<!--placeholder -->

{logging_objects_with_schema-0.4.0 → logging_objects_with_schema-1.0.0}/README.md

@@ -28,6 +28,9 @@ systems) can rely on a consistent log structure.
   problem.
 - Any mismatch between runtime values and the declared types (wrong types,
   `None` values, disallowed list elements) is also treated as a data error.
+  Type checks use `type()`, not `isinstance()`: `bool` is **not** accepted
+  where `int` is declared, and `int` is **not** accepted where `float` is
+  declared. There are no implicit type conversions.
 - All validation problems are aggregated and logged as a single ERROR message
   **after** the log record has been emitted, ensuring 100% compatibility with
   standard logger behavior (no exceptions are raised).
@@ -145,7 +148,9 @@ directory until it finds the file or reaches the filesystem root.
 **Important**: If there are any problems with the schema (missing file, broken
 JSON, invalid structure, etc.), the application is terminated after logging
 schema problems to stderr. Schema validation happens when the first logger
-instance is created.
+instance is created. Termination uses `os._exit(1)` — bypassing `atexit`
+handlers and `finally` blocks — to prevent any cleanup code from running
+against a broken logger that was never fully registered.
 
 **Note**: The schema is compiled once per process and cached. Schema changes
 require an application restart to take effect. The library is thread-safe.
@@ -341,3 +346,5 @@ All keys are merged together - they are not replaced, only supplemented.
   keys are used, maintaining 100% backward compatibility
 - `None` and empty `set()` are semantically equivalent for `forbidden_keys` -
   both mean "no additional forbidden keys" and produce the same result
+
+<!--placeholder -->

{logging_objects_with_schema-0.4.0 → logging_objects_with_schema-1.0.0}/pyproject.toml

@@ -4,10 +4,10 @@ build-backend = "uv_build"
 
 [project]
 name = "logging-objects-with-schema"
-version = "0.4.0"
+version = "1.0.0"
 description = "Proxy logging wrapper that validates extra fields against a JSON schema."
 readme = "README.md"
-requires-python = ">=3.10"
+requires-python = ">=3.11"
 dependencies = [ ]
 license = "Apache-2.0"
 license-files = [ "LICENSE" ]
@@ -20,7 +20,6 @@ keywords = [
 ]
 classifiers = [
   "Programming Language :: Python :: 3",
-  "Programming Language :: Python :: 3.10",
   "Programming Language :: Python :: 3.11",
   "Programming Language :: Python :: 3.12",
   "Programming Language :: Python :: 3.13",
@@ -102,6 +101,7 @@ source = [ "src" ]
 branch = true
 
 [tool.coverage.report]
+fail_under = 100
 exclude_lines = [
   "def __repr__",
   "if self\\.debug",

{logging_objects_with_schema-0.4.0 → logging_objects_with_schema-1.0.0}/src/logging_objects_with_schema/__init__.py

@@ -5,8 +5,6 @@ logging package that validates and filters user-provided extra fields
 according to an application-defined JSON schema.
 """
 
-from __future__ import annotations
-
 from .schema_logger import SchemaLogger
 
 __all__ = [

{logging_objects_with_schema-0.4.0 → logging_objects_with_schema-1.0.0}/src/logging_objects_with_schema/errors.py

@@ -1,8 +1,8 @@
 """Custom exception types used by logging_objects_with_schema."""
 
-from __future__ import annotations
-
+import json
 from dataclasses import dataclass
+from typing import Any
 
 
 @dataclass
@@ -60,15 +60,12 @@ class _DataProblem:
     - Redundant fields (fields not defined in the schema)
 
     Attributes:
-        message: JSON string containing structured error information. The message
-            is always a valid JSON object with the following structure:
-            ``{"field": "...", "error": "...", "value": "..."}``
-            All values are serialized via ``repr()`` for safety and consistency.
-            Examples:
-            - ``{"field": "'user_id'", "error": "'has type str, expected int'", "value": "'abc-123'"}``
-            - ``{"field": "'request_id'", "error": "'is None'", "value": "None"}``
-            - ``{"field": "'tags'", "error": "'is a list but contains elements with types dict; expected all elements to be of type str'", "value": "[{'key': 'color'}]"}``  # noqa: E501
-            - ``{"field": "'unknown_field'", "error": "'is not defined in schema'", "value": "'some_value'"}``
+        data: Dict containing structured error information with keys
+            ``field``, ``error``, and ``value`` (all via ``repr()``).
     """
 
-    message: str
+    data: dict[str, Any]
+
+    @property
+    def message(self) -> str:
+        return json.dumps(self.data)

{logging_objects_with_schema-0.4.0 → logging_objects_with_schema-1.0.0}/src/logging_objects_with_schema/schema_applier.py

@@ -4,10 +4,6 @@ This module provides the core function for applying a compiled schema
 to user-provided extra fields, used by SchemaLogger.
 """
 
-from __future__ import annotations
-
-import json
-from collections import defaultdict
 from collections.abc import Mapping, MutableMapping
 from typing import Any
 
@@ -15,14 +11,11 @@ from .errors import _DataProblem
 from .schema_loader import _CompiledSchema, _SchemaLeaf
 
 
-def _create_validation_error_json(field: str, error: str, value: Any) -> str:
-    """Create JSON string for a single validation error.
+def _create_validation_error_dict(field: str, error: str, value: Any) -> dict[str, Any]:
+    """Create a dict for a single validation error.
 
-    All values are wrapped in repr() before JSON serialization. This ensures:
-    - Any value type can be safely serialized (even non-JSON-serializable types)
-    - The error message always contains a valid Python representation of the value
-    - Security: prevents issues with special characters or control sequences
-    - Consistency: all error messages have the same format regardless of value type
+    All values are wrapped in repr() to ensure any type is representable
+    and special characters cannot cause issues downstream.
 
     Args:
         field: Field name that caused the validation error.
@@ -30,15 +23,13 @@ def _create_validation_error_json(field: str, error: str, value: Any) -> str:
         value: Invalid value that caused the error.
 
     Returns:
-        JSON string with field, error, and value (all via repr() for safety).
+        Dict with field, error, and value (all via repr() for safety).
     """
-    return json.dumps(
-        {
-            "field": repr(field),
-            "error": repr(error),
-            "value": repr(value),
-        }
-    )
+    return {
+        "field": repr(field),
+        "error": repr(error),
+        "value": repr(value),
+    }
 
 
 def _validate_list_value(
@@ -62,16 +53,12 @@ def _validate_list_value(
     """
     if item_expected_type is None:
         error_msg = "is a list but has no item type configured"
-        return _DataProblem(_create_validation_error_json(source, error_msg, value))
+        return _DataProblem(_create_validation_error_dict(source, error_msg, value))
 
     if len(value) == 0:
-        # Empty lists are always valid
         return None
 
-    # Collect unique type names of items that don't match the expected type.
-    # We use a set comprehension to get unique type names (not the types themselves)
-    # for the error message. This gives a clear, readable error message showing
-    # which types were found (e.g., "int, str") vs what was expected.
+    # __name__ gives "int, str" in error messages instead of "<class 'int'>".
     invalid_item_types = {
         type(item).__name__ for item in value if type(item) is not item_expected_type
     }
@@ -83,7 +70,7 @@ def _validate_list_value(
             f"expected all elements to be of type "
             f"{item_expected_type.__name__}"
         )
-        return _DataProblem(_create_validation_error_json(source, error_msg, value))
+        return _DataProblem(_create_validation_error_dict(source, error_msg, value))
 
     return None
 
@@ -104,22 +91,14 @@ def _set_nested_value(
         value: The value to set at the target location.
     """
     current = target
-    # Navigate through intermediate dictionaries, creating them as needed.
-    # We iterate through all keys except the last one (path[:-1]) to build
-    # the nested structure.
     for key in path[:-1]:
         child = current.get(key)
-        # If the key doesn't exist or exists but is not a dict, create a new dict.
-        # This overwrites any non-dict value that might have been there (which
-        # shouldn't happen in normal operation, but we handle it defensively).
-        # We use isinstance() instead of checking for None because we need to
-        # ensure the value is actually a dict, not just that the key exists.
+        # isinstance catches both missing keys and non-dict values at the same key.
         if not isinstance(child, dict):
             child = {}
             current[key] = child
         current = child
 
-    # Set the final value at the last key in the path
     current[path[-1]] = value
 
 
@@ -142,24 +121,18 @@ def _validate_and_apply_leaf(
         extra: The target dictionary to write the value to if validation passes.
         problems: List to append validation problems to.
     """
-    # Use strict type checking (type() is) instead of isinstance() to
-    # prevent bool values from passing validation for int types (since
-    # bool is a subclass of int). This ensures that the actual
-    # runtime type matches the schema type exactly.
+    # type() is, not isinstance(): bool subclasses int and must not pass int validation.
     if type(value) is not leaf.expected_type:
         error_msg = (
             f"has type {type(value).__name__}, "
             f"expected {leaf.expected_type.__name__}"
         )
         problems.append(
-            _DataProblem(_create_validation_error_json(source, error_msg, value))
+            _DataProblem(_create_validation_error_dict(source, error_msg, value))
         )
         return
 
-    # For lists, validate that all elements strictly match the declared
-    # item_expected_type (homogeneous primitive list).
-    # Note: isinstance() check is needed for type narrowing (mypy), even though
-    # type(value) is list is already guaranteed by the check above.
+    # isinstance() for mypy narrowing; type(value) is list is already guaranteed above.
     if leaf.expected_type is list and isinstance(value, list):
         list_problem = _validate_list_value(value, source, leaf.item_expected_type)
         if list_problem is not None:
@@ -197,8 +170,12 @@ def _strip_empty(node: Any) -> Any:
         The cleaned structure with empty dicts and None values removed.
     """
     if isinstance(node, dict):
-        cleaned = {k: _strip_empty(v) for k, v in node.items()}
-        return {k: v for k, v in cleaned.items() if v != {} and v is not None}
+        result: dict[str, Any] = {}
+        for k, v in node.items():
+            v = _strip_empty(v)
+            if v != {} and v is not None:
+                result[k] = v
+        return result
     return node
 
 
@@ -274,63 +251,31 @@ def _apply_schema_internal(
     extra: dict[str, Any] = {}
     problems: list[_DataProblem] = []
 
-    # Group leaves by source field name. This is necessary because a single source
-    # can be referenced by multiple leaves (allowing the same value to appear in
-    # different locations in the output structure). Grouping allows us to process
-    # all leaves for a given source together, which is more efficient and allows
-    # us to validate the value once per source (e.g., checking for None) rather
-    # than once per leaf.
-    source_to_leaves: dict[str, list[_SchemaLeaf]] = defaultdict(list)
-    for leaf in compiled.leaves:
-        source_to_leaves[leaf.source].append(leaf)
-
-    used_sources = set(source_to_leaves.keys())
-
-    # Process each source that appears in the schema. If a source is missing from
-    # extra_values, we silently skip it (this is normal - not all sources need to
-    # be present in every log call). We only validate and apply sources that are
-    # actually provided.
-    for source, leaves in source_to_leaves.items():
+    for source, leaves in compiled.source_to_leaves.items():
         if source not in extra_values:
-            # Source not provided - this is normal, not an error. Skip it.
             continue
 
         value = extra_values[source]
 
-        # Check for None values explicitly. None is never allowed for any type,
-        # so we check it once per source (not once per leaf) before attempting
-        # type-specific validation. This avoids redundant checks when a source
-        # is used by multiple leaves.
         if value is None:
-            error_msg = "is None"
             problems.append(
-                _DataProblem(_create_validation_error_json(source, error_msg, None))
+                _DataProblem(_create_validation_error_dict(source, "is None", None))
             )
             continue
 
-        # Validate the value against each leaf that references this source.
-        # Each leaf validates independently, so a value might pass validation
-        # for some leaves (where type matches) but fail for others (where type
-        # doesn't match). The value is written only to locations where validation
-        # succeeds.
         for leaf in leaves:
             _validate_and_apply_leaf(leaf, value, source, extra, problems)
 
-    # Report redundant fields: any keys in extra_values that are not referenced
-    # by any schema leaf. These are fields that the user provided but which are
-    # not defined in the schema, so they cannot be included in the log output.
-    # Optimization: if schema is empty (no used_sources), all fields are redundant,
-    # so we can skip the membership check for each key.
     redundant_keys = (
         extra_values.keys()
-        if not used_sources
-        else (key for key in extra_values.keys() if key not in used_sources)
+        if not compiled.known_sources
+        else (key for key in extra_values.keys() if key not in compiled.known_sources)
     )
     for key in redundant_keys:
         error_msg = "is not defined in schema"
         problems.append(
             _DataProblem(
-                _create_validation_error_json(key, error_msg, extra_values[key])
+                _create_validation_error_dict(key, error_msg, extra_values[key])
             )
         )