dynamic-config-loader 2.0.0__tar.gz → 2.2.0__tar.gz

{dynamic_config_loader-2.0.0/src/dynamic_config_loader.egg-info → dynamic_config_loader-2.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dynamic-config-loader
-Version: 2.0.0
+Version: 2.2.0
 Summary: An enterprise-grade configuration orchestration engine designed to ingest, cascade, and deeply merge multiple configuration file layers.
 Author-email: Avinash Kumar <halfhiddencode@gmail.com>
 License: 

{dynamic_config_loader-2.0.0 → dynamic_config_loader-2.2.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "dynamic-config-loader"
-version = "2.0.0"
+version = "2.2.0"
 description = "An enterprise-grade configuration orchestration engine designed to ingest, cascade, and deeply merge multiple configuration file layers."
 readme = "README.md"
 requires-python = ">=3.8"

dynamic_config_loader-2.2.0/src/dynamic_config_loader/environment.py

@@ -0,0 +1,121 @@
+# -*- coding: utf-8 -*-
+
+# SPDX-License-Identifier: Apache-2.0
+# Copyright (C) 2026 Avinash Kumar
+
+"""
+Environment Variable Injection Module.
+
+Handles scanning, case-normalization, single-underscore parsing, and deep-merging
+of system environment variable parameters into the main configuration matrix.
+"""
+
+import logging
+import os
+from typing import Any, Dict
+
+logger = logging.getLogger(__name__)
+
+
+def _parse_env_value(val: str) -> Any:
+    """
+    Parses environment variable string values into standard primitives (bool, int, float, str).
+    """
+    val_lower = val.strip().lower()
+    if val_lower == "true":
+        return True
+    if val_lower == "false":
+        return False
+    try:
+        return int(val)
+    except ValueError:
+        pass
+    try:
+        return float(val)
+    except ValueError:
+        pass
+    return val.strip()
+
+
+def inject_environment_variables(
+    config_data: Dict[str, Any], prefix: str, mask_secrets: bool
+) -> None:
+    """
+    Scans the system environment variables and overlays matching prefix keys
+    into the config_data dictionary using a single-underscore delimiter structure.
+
+    Args:
+        config_data (Dict[str, Any]): The configuration dictionary to mutate.
+        prefix (str): Prefix string to filter variables (e.g. "DCL_").
+        mask_secrets (bool): Whether to mask values in diagnostic logs.
+    """
+    if os.environ.get("DCL_ENV_LOADER", "").strip().lower() != "true":
+        return
+
+    for env_key, env_val in os.environ.items():
+        if env_key.startswith(prefix):
+            # Strip prefix
+            sliced_key = env_key[len(prefix):]
+            if not sliced_key:
+                continue
+
+            # Case Normalization and tokenizing
+            parts = [p.lower() for p in sliced_key.split("_") if p]
+            if not parts:
+                continue
+
+            # Reconstruct current_path in dot-notation for logging
+            current_path = ".".join(parts)
+
+            # Parse the env value
+            parsed_val = _parse_env_value(env_val)
+
+            # Traverse config_data to insert
+            curr = config_data
+            for part in parts[:-1]:
+                if part not in curr or not isinstance(curr[part], dict):
+                    curr[part] = {}
+                curr = curr[part]
+
+            last_key = parts[-1]
+
+            # Check if key already exists for logging
+            if last_key in curr:
+                old_val = curr[last_key]
+                if old_val != parsed_val:
+                    if logger.isEnabledFor(logging.DEBUG):
+                        if not mask_secrets:
+                            logger.debug(
+                                f"Overriding configuration path '{current_path}' from environment: "
+                                f"{repr(old_val)} -> {repr(parsed_val)}"
+                            )
+                        else:
+                            logger.debug(
+                                f"Overriding configuration path '{current_path}' from environment: "
+                                f"[REDACTED] -> [REDACTED]"
+                            )
+                    else:
+                        logger.info(
+                            f"Overriding configuration path from environment variable: "
+                            f"{current_path} [Value Redacted]"
+                        )
+                    curr[last_key] = parsed_val
+            else:
+                # New key insertion
+                if logger.isEnabledFor(logging.DEBUG):
+                    if not mask_secrets:
+                        logger.debug(
+                            f"Injecting new configuration path '{current_path}' from environment: "
+                            f"{repr(parsed_val)}"
+                        )
+                    else:
+                        logger.debug(
+                            f"Injecting new configuration path '{current_path}' from environment: "
+                            f"[REDACTED]"
+                        )
+                else:
+                    logger.info(
+                        f"Overriding configuration path from environment variable: "
+                        f"{current_path} [Value Redacted]"
+                    )
+                curr[last_key] = parsed_val

{dynamic_config_loader-2.0.0 → dynamic_config_loader-2.2.0}/src/dynamic_config_loader/loader.py

@@ -18,6 +18,7 @@ from typing import Any, Dict, Optional
 
 # Import your central factory router to replace the local self._handlers dictionary
 from dynamic_config_loader.strategies import factory
+from dynamic_config_loader.environment import inject_environment_variables
 
 logger = logging.getLogger(__name__)
 
@@ -30,13 +31,14 @@ class DynamicConfigLoader:
     from both static baseline tracks and dynamic environment target vectors.
     """
 
-    def __init__(self, default_config_path: Optional[str] = None) -> None:
+    def __init__(self, default_config_path: Optional[str] = None, prefix: str = "DCL_") -> None:
         """
         Initializes the dynamic runtime configuration engine instance.
 
         Args:
             default_config_path (str, optional): System target string pointer
                 to the baseline configuration data asset. Defaults to None.
+            prefix (str): Prefix string for environment variable injection. Defaults to "DCL_".
         """
         # Central memory state tracking core mapping parameters
         self.config_data: Dict[str, Any] = {}
@@ -46,6 +48,8 @@ class DynamicConfigLoader:
             Path(default_config_path) if default_config_path else None
         )
 
+        self.prefix = prefix
+
     def load(self) -> Dict[str, Any]:
         """
         Executes structural loops traversing the pipeline layers.
@@ -68,6 +72,13 @@ class DynamicConfigLoader:
                 "======================================================================="
             )
 
+        # Resolve the allowed format strategy class based on the baseline configuration file extension
+        allowed_strategy_cls = None
+        if self.default_path:
+            base_strategy = factory.get_strategy(self.default_path.suffix)
+            if base_strategy:
+                allowed_strategy_cls = type(base_strategy)
+
         # Pipeline Phase 1: Assess and ingest baseline layer properties
         if self.default_path and self.default_path.exists():
             # Dynamically look up the decoupled format strategy class using the extension suffix
@@ -109,6 +120,12 @@ class DynamicConfigLoader:
                         if file_path.is_file():
                             strategy = factory.get_strategy(file_path.suffix)
                             if strategy:
+                                if allowed_strategy_cls and not isinstance(strategy, allowed_strategy_cls):
+                                    logger.warning(
+                                        f"Skipping override file '{file_path.name}' due to format mismatch "
+                                        f"with baseline strategy '{allowed_strategy_cls.__name__}'."
+                                    )
+                                    continue
                                 try:
                                     logger.info(f"Processing override layer discovery file: {file_path.name}")
                                     extra_data = strategy.parse(file_path)
@@ -125,6 +142,12 @@ class DynamicConfigLoader:
                 elif current_path.is_file():
                     strategy = factory.get_strategy(current_path.suffix)
                     if strategy:
+                        if allowed_strategy_cls and not isinstance(strategy, allowed_strategy_cls):
+                            logger.warning(
+                                f"Skipping direct override file asset '{current_path.name}' due to format mismatch "
+                                f"with baseline strategy '{allowed_strategy_cls.__name__}'."
+                            )
+                            continue
                         try:
                             logger.info(f"Processing direct override file asset: {current_path.name}")
                             extra_data = strategy.parse(current_path)
@@ -141,4 +164,7 @@ class DynamicConfigLoader:
                             f"Unsupported file format extension for direct asset override: {current_path.name}"
                         )
 
+        # Pipeline Phase 3: Native Environment Variable Injection Track
+        inject_environment_variables(self.config_data, self.prefix, self.mask_secrets)
+
         return self.config_data

{dynamic_config_loader-2.0.0 → dynamic_config_loader-2.2.0}/src/dynamic_config_loader/strategies/__init__.py

@@ -15,6 +15,7 @@ from dynamic_config_loader.strategies.base_strategy import BaseStrategy
 
 # Import the strategy worker class from the underlying yaml package
 from dynamic_config_loader.strategies.yaml import YamlStrategy
+from dynamic_config_loader.strategies.json import JsonStrategy
 
 
 class StrategyFactory:
@@ -26,10 +27,11 @@ class StrategyFactory:
         """
         Initializes the factory and registers file extension routes to concrete strategy objects.
         """
-        # Register extension routes straight to your isolated yaml folder class
+        # Register extension routes straight to your isolated strategy classes
         self._strategies: Dict[str, BaseStrategy] = {
             ".yaml": YamlStrategy(),
-            ".yml": YamlStrategy()
+            ".yml": YamlStrategy(),
+            ".json": JsonStrategy(),
         }
 
     def get_strategy(self, extension: str) -> Optional[BaseStrategy]:

dynamic_config_loader-2.2.0/src/dynamic_config_loader/strategies/json/__init__.py

@@ -0,0 +1,34 @@
+# -*- coding: utf-8 -*-
+
+# SPDX-License-Identifier: Apache-2.0
+# Copyright (C) 2026 Avinash Kumar
+
+"""
+JSON Strategy Package Initializer.
+
+Exposes the concrete JsonStrategy engine implementation.
+"""
+
+from pathlib import Path
+from typing import Any, Dict
+from dynamic_config_loader.strategies.base_strategy import BaseStrategy
+from dynamic_config_loader.strategies.json.parser import parse_json_file
+from dynamic_config_loader.strategies.json.merger import execute_json_deep_merge
+
+
+class JsonStrategy(BaseStrategy):
+    """
+    Concrete Strategy implementation managing the processing life cycle of JSON configurations.
+    """
+
+    def parse(self, file_path: Path) -> Dict[str, Any]:
+        return parse_json_file(file_path)
+
+    def merge(
+        self,
+        base_dict: Dict[str, Any],
+        update_dict: Dict[str, Any],
+        path: str = "",
+        mask_secrets: bool = True,
+    ) -> None:
+        execute_json_deep_merge(base_dict, update_dict, path=path, mask_secrets=mask_secrets)

dynamic_config_loader-2.2.0/src/dynamic_config_loader/strategies/json/merger.py

@@ -0,0 +1,63 @@
+# -*- coding: utf-8 -*-
+
+# SPDX-License-Identifier: Apache-2.0
+# Copyright (C) 2026 Avinash Kumar
+
+"""
+JSON Merging Strategy Module.
+
+Provides recursive tree-merging algorithms engineered to blend cascading JSON layers.
+"""
+
+import logging
+from typing import Any, Dict
+
+logger = logging.getLogger(__name__)
+
+
+def execute_json_deep_merge(
+    base_dict: Dict[str, Any],
+    update_dict: Dict[str, Any],
+    path: str = "",
+    mask_secrets: bool = True,
+) -> None:
+    """
+    Recursively deep-merges update_dict into base_dict in-place.
+    """
+    for key, value in update_dict.items():
+        current_path = f"{path}.{key}" if path else key
+
+        # Case A: Both values are dictionaries -> recurse
+        if key in base_dict and isinstance(base_dict[key], dict) and isinstance(value, dict):
+            logger.debug(f"Deep merging nested JSON structure at path: {current_path}")
+            execute_json_deep_merge(base_dict[key], value, path=current_path, mask_secrets=mask_secrets)
+
+        # Case B: Structural conflict or key exists
+        elif key in base_dict:
+            if isinstance(base_dict[key], dict) or isinstance(value, dict):
+                logger.warning(
+                    f"Type mismatch conflict detected at path '{current_path}'. "
+                    f"Overwriting base JSON structural type ({type(base_dict[key]).__name__}) "
+                    f"with incoming type ({type(value).__name__})."
+                )
+                base_dict[key] = value
+            else:
+                if base_dict[key] != value:
+                    if logger.isEnabledFor(logging.DEBUG):
+                        if not mask_secrets:
+                            logger.debug(f"Updating JSON path '{current_path}': {repr(base_dict[key])} -> {repr(value)}")
+                        else:
+                            logger.debug(f"Updating JSON path '{current_path}': [REDACTED] -> [REDACTED]")
+                    else:
+                        logger.info(f"Updating configuration attribute path: {current_path} [Value Redacted]")
+                    base_dict[key] = value
+        # Case C: New key
+        else:
+            if logger.isEnabledFor(logging.DEBUG):
+                if not mask_secrets:
+                    logger.debug(f"Adding new JSON key at path '{current_path}': {repr(value)}")
+                else:
+                    logger.debug(f"Adding new JSON key at path '{current_path}': [REDACTED]")
+            else:
+                logger.info(f"Adding new configuration attribute path: {current_path} [Value Redacted]")
+            base_dict[key] = value

dynamic_config_loader-2.2.0/src/dynamic_config_loader/strategies/json/parser.py

@@ -0,0 +1,40 @@
+# -*- coding: utf-8 -*-
+
+# SPDX-License-Identifier: Apache-2.0
+# Copyright (C) 2026 Avinash Kumar
+
+"""
+JSON Parsing Strategy Module.
+
+Provides isolated, low-level file stream ingestion utilities optimized
+for handling standard JSON configuration assets.
+"""
+
+import json
+import logging
+from pathlib import Path
+from typing import Any, Dict
+
+logger = logging.getLogger(__name__)
+
+
+def parse_json_file(file_path: Path) -> Dict[str, Any]:
+    """
+    Reads a JSON configuration file asset from disk and returns a dictionary mapping.
+    """
+    try:
+        with open(file_path, "r", encoding="utf-8") as f:
+            data = json.load(f)
+            if data is None:
+                logger.info(f"Target JSON file context is empty or unassigned: {file_path.name}")
+                return {}
+            if isinstance(data, dict):
+                return data
+            logger.warning(
+                f"Invalid structural layout detected inside file: {file_path.name}. "
+                f"Expected key-value schema tree map, but received root type: {type(data).__name__}."
+            )
+            return {}
+    except (json.JSONDecodeError, IOError, PermissionError) as e:
+        logger.exception(f"Failed to read or parse JSON file: {file_path.name}", exc_info=e)
+        return {}

{dynamic_config_loader-2.0.0 → dynamic_config_loader-2.2.0/src/dynamic_config_loader.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dynamic-config-loader
-Version: 2.0.0
+Version: 2.2.0
 Summary: An enterprise-grade configuration orchestration engine designed to ingest, cascade, and deeply merge multiple configuration file layers.
 Author-email: Avinash Kumar <halfhiddencode@gmail.com>
 License: 

{dynamic_config_loader-2.0.0 → dynamic_config_loader-2.2.0}/src/dynamic_config_loader.egg-info/SOURCES.txt

@@ -13,10 +13,15 @@ src/dynamic_config_loader.egg-info/requires.txt
 src/dynamic_config_loader.egg-info/top_level.txt
 src/dynamic_config_loader/strategies/__init__.py
 src/dynamic_config_loader/strategies/base_strategy.py
+src/dynamic_config_loader/strategies/json/__init__.py
+src/dynamic_config_loader/strategies/json/merger.py
+src/dynamic_config_loader/strategies/json/parser.py
 src/dynamic_config_loader/strategies/yaml/__init__.py
 src/dynamic_config_loader/strategies/yaml/merger.py
 src/dynamic_config_loader/strategies/yaml/parser.py
 tests/test_deep_merge.py
+tests/test_env_injection.py
 tests/test_factory.py
+tests/test_json_strategy.py
 tests/test_loader.py
 tests/test_logging_safety.py

dynamic_config_loader-2.2.0/tests/test_env_injection.py

@@ -0,0 +1,99 @@
+# -*- coding: utf-8 -*-
+
+import logging
+import os
+import unittest
+from pathlib import Path
+from dynamic_config_loader.loader import DynamicConfigLoader
+
+
+class TestEnvInjection(unittest.TestCase):
+
+    def setUp(self):
+        # Clean environment variables
+        for key in list(os.environ.keys()):
+            if key.startswith("DCL_") or key.startswith("MYAPP_") or key == "ENABLE_UNSAFE_LOGGING":
+                del os.environ[key]
+        
+        self.TEST_DIR = Path(__file__).parent
+        self.base_file = self.TEST_DIR / "test_configs" / "base_config.yaml"
+
+    def tearDown(self):
+        for key in list(os.environ.keys()):
+            if key.startswith("DCL_") or key.startswith("MYAPP_") or key == "ENABLE_UNSAFE_LOGGING":
+                del os.environ[key]
+
+    def test_injection_disabled_by_default(self):
+        """
+        Verifies that environment variable injection is skipped if DCL_ENV_LOADER is not true.
+        """
+        os.environ["DCL_SERVER_PORT"] = "9000"
+        loader = DynamicConfigLoader(default_config_path=str(self.base_file))
+        result = loader.load()
+
+        # The port from base_config.yaml is 5432 and must remain unchanged
+        self.assertEqual(result["database"]["port"], 5432)
+
+    def test_injection_default_prefix(self):
+        """
+        Verifies that configuration parameters are injected correctly with the default prefix.
+        """
+        os.environ["DCL_ENV_LOADER"] = "true"
+        os.environ["DCL_DATABASE_PORT"] = "9000"
+        os.environ["DCL_DATABASE_USER"] = "postgres_env"
+        os.environ["DCL_NEW_FEATURE_ENABLED"] = "true"
+
+        loader = DynamicConfigLoader(default_config_path=str(self.base_file))
+        result = loader.load()
+
+        # Check nested structures are created or overridden
+        self.assertEqual(result["database"]["port"], 9000)  # String "9000" is parsed to int 9000
+        self.assertEqual(result["database"]["user"], "postgres_env")
+        self.assertTrue(result["new"]["feature"]["enabled"])  # String "true" is parsed to bool True
+
+    def test_injection_custom_prefix(self):
+        """
+        Verifies that configuration parameters are injected correctly using a custom prefix.
+        """
+        os.environ["DCL_ENV_LOADER"] = "true"
+        os.environ["MYAPP_DB_HOST"] = "remote.db"
+
+        # Pass custom prefix to constructor
+        loader = DynamicConfigLoader(default_config_path=str(self.base_file), prefix="MYAPP_")
+        result = loader.load()
+
+        self.assertEqual(result["db"]["host"], "remote.db")
+        # Ensure default DCL_ prefix is ignored when custom prefix is active
+        os.environ["DCL_DB_HOST"] = "local.db"
+        self.assertNotIn("database", result.get("db", {}))
+
+    def test_injection_log_masking(self):
+        """
+        Verifies that log output respects mask_secrets parameter during injection.
+        """
+        os.environ["DCL_ENV_LOADER"] = "true"
+        os.environ["DCL_DATABASE_PORT"] = "9999"
+
+        loader = DynamicConfigLoader(default_config_path=str(self.base_file))
+
+        # Safe Debug (Default mask_secrets=True)
+        with self.assertLogs("dynamic_config_loader", level=logging.DEBUG) as log_capture:
+            loader.load()
+        
+        log_messages = "\n".join(log_capture.output)
+        self.assertIn("[REDACTED]", log_messages)
+        self.assertNotIn("9999", log_messages)
+
+        # Unsafe Debug (mask_secrets=False via ENABLE_UNSAFE_LOGGING)
+        os.environ["ENABLE_UNSAFE_LOGGING"] = "true"
+        loader_unsafe = DynamicConfigLoader(default_config_path=str(self.base_file))
+        with self.assertLogs("dynamic_config_loader", level=logging.DEBUG) as log_capture_unsafe:
+            loader_unsafe.load()
+        
+        log_messages_unsafe = "\n".join(log_capture_unsafe.output)
+        self.assertIn("9999", log_messages_unsafe)
+        self.assertNotIn("[REDACTED]", log_messages_unsafe)
+
+
+if __name__ == "__main__":
+    unittest.main()

{dynamic_config_loader-2.0.0 → dynamic_config_loader-2.2.0}/tests/test_factory.py

@@ -3,6 +3,7 @@
 import unittest
 from dynamic_config_loader.strategies import factory
 from dynamic_config_loader.strategies.yaml import YamlStrategy
+from dynamic_config_loader.strategies.json import JsonStrategy
 
 
 class TestStrategyFactory(unittest.TestCase):
@@ -14,9 +15,11 @@ class TestStrategyFactory(unittest.TestCase):
         # Test standard extensions
         strategy_yaml = factory.get_strategy(".yaml")
         strategy_yml = factory.get_strategy(".yml")
+        strategy_json = factory.get_strategy(".json")
 
         self.assertIsInstance(strategy_yaml, YamlStrategy)
         self.assertIsInstance(strategy_yml, YamlStrategy)
+        self.assertIsInstance(strategy_json, JsonStrategy)
 
     def test_factory_case_insensitivity(self):
         """
@@ -24,15 +27,16 @@ class TestStrategyFactory(unittest.TestCase):
         """
         strategy_mixed = factory.get_strategy(".YaMl")
         strategy_upper = factory.get_strategy(".YML")
+        strategy_json_upper = factory.get_strategy(".JSON")
 
         self.assertIsInstance(strategy_mixed, YamlStrategy)
         self.assertIsInstance(strategy_upper, YamlStrategy)
+        self.assertIsInstance(strategy_json_upper, JsonStrategy)
 
     def test_factory_unsupported_extensions(self):
         """
         Verifies that StrategyFactory returns None for unregistered extensions.
         """
-        self.assertIsNone(factory.get_strategy(".json"))
         self.assertIsNone(factory.get_strategy(".xml"))
         self.assertIsNone(factory.get_strategy(".ini"))
 

dynamic_config_loader-2.2.0/tests/test_json_strategy.py

@@ -0,0 +1,112 @@
+# -*- coding: utf-8 -*-
+
+import logging
+import os
+import unittest
+from pathlib import Path
+from dynamic_config_loader.loader import DynamicConfigLoader
+from dynamic_config_loader.strategies.json.parser import parse_json_file
+from dynamic_config_loader.strategies.json.merger import execute_json_deep_merge
+
+
+class TestJsonStrategy(unittest.TestCase):
+
+    def setUp(self):
+        self.TEST_DIR = Path(__file__).parent
+        self.base_file = self.TEST_DIR / "test_configs" / "base_config.json"
+        self.overrides_dir = self.TEST_DIR / "test_configs" / "overrides"
+
+        # Clear env variables
+        if "PYTHON_ADDITIONAL_CONFIG" in os.environ:
+            del os.environ["PYTHON_ADDITIONAL_CONFIG"]
+        if "ENABLE_UNSAFE_LOGGING" in os.environ:
+            del os.environ["ENABLE_UNSAFE_LOGGING"]
+
+    def tearDown(self):
+        if "PYTHON_ADDITIONAL_CONFIG" in os.environ:
+            del os.environ["PYTHON_ADDITIONAL_CONFIG"]
+        if "ENABLE_UNSAFE_LOGGING" in os.environ:
+            del os.environ["ENABLE_UNSAFE_LOGGING"]
+
+    def test_json_parsing(self):
+        """
+        Verifies that parse_json_file correctly parses JSON files into dictionaries.
+        """
+        data = parse_json_file(self.base_file)
+        self.assertEqual(data["app_name"], "Test JSON Gateway")
+        self.assertEqual(data["database"]["port"], 5432)
+
+    def test_json_deep_merging(self):
+        """
+        Verifies recursive deep merges and type mismatch resolution for JSON structures.
+        """
+        base = {
+            "debug": False,
+            "database": {
+                "host": "localhost",
+                "settings": {"pool": 10}
+            }
+        }
+        update = {
+            "debug": True,
+            "database": {
+                "settings": {"pool": 20, "timeout": 30}
+            }
+        }
+
+        execute_json_deep_merge(base, update)
+
+        self.assertTrue(base["debug"])
+        self.assertEqual(base["database"]["host"], "localhost")
+        self.assertEqual(base["database"]["settings"]["pool"], 20)
+        self.assertEqual(base["database"]["settings"]["timeout"], 30)
+
+    def test_json_loader_integration(self):
+        """
+        Verifies that DynamicConfigLoader correctly orchestrates baseline JSON and directory overrides JSON.
+        """
+        # Set overrides path in env
+        os.environ["PYTHON_ADDITIONAL_CONFIG"] = str(self.overrides_dir)
+
+        loader = DynamicConfigLoader(default_config_path=str(self.base_file))
+        result = loader.load()
+
+        # baseline JSON: Test JSON Gateway, overrides folder has 01_dev_patch.json overriding database host
+        self.assertEqual(result["app_name"], "Test JSON Gateway")
+        self.assertTrue(result["debug_mode"])
+        self.assertEqual(result["database"]["host"], "json-dev-cluster.local")
+        self.assertEqual(result["database"]["port"], 5432)
+
+    def test_json_log_masking(self):
+        """
+        Verifies that logging of updates/additions for JSON conforms to mask_secrets checks.
+        """
+        base = {"db_pass": "old_secret"}
+        update = {"db_pass": "new_secret"}
+
+        # Safe logs (default mask_secrets=True)
+        with self.assertLogs("dynamic_config_loader", level=logging.DEBUG) as log_capture:
+            execute_json_deep_merge(base, update, mask_secrets=True)
+
+        log_messages = "\n".join(log_capture.output)
+        self.assertIn("[REDACTED]", log_messages)
+        self.assertNotIn("new_secret", log_messages)
+
+        # Reset base to ensure the second execution performs an update and triggers log outputs
+        base = {"db_pass": "old_secret"}
+
+        # Unsafe logs (mask_secrets=False via ENABLE_UNSAFE_LOGGING setting)
+        os.environ["ENABLE_UNSAFE_LOGGING"] = "true"
+        loader_unsafe = DynamicConfigLoader(default_config_path=str(self.base_file))
+        loader_unsafe.load()  # Resolves self.mask_secrets to False
+
+        with self.assertLogs("dynamic_config_loader", level=logging.DEBUG) as log_capture_unsafe:
+            execute_json_deep_merge(base, update, mask_secrets=loader_unsafe.mask_secrets)
+
+        log_messages_unsafe = "\n".join(log_capture_unsafe.output)
+        self.assertIn("new_secret", log_messages_unsafe)
+        self.assertNotIn("[REDACTED]", log_messages_unsafe)
+
+
+if __name__ == "__main__":
+    unittest.main()