fix: make configure_logger resilient to PermissionError on mounted data dirs

- Adds stderr sink before attempting file logging so startup never crashes
- Wraps DATA_DIR.mkdir + logger.add(file) in try/except (PermissionError, OSError)
- Falls back to console-only logging with a warning showing exception type only
  (avoids exposing system paths in log messages)
- Adds threading.Lock with double-checked locking for thread-safety
- Adds 5 new tests covering happy path, PermissionError/OSError on mkdir,
  PermissionError on file add, and idempotency of the configured flag

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: dvilelaf

pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "iwa"
-version = "0.8.1"
+version = "0.8.2"
 description = "A secure, modular, and plugin-based framework for crypto agents and ops"
 readme = "README.md"
 requires-python = ">=3.12,<4.0"

src/iwa/core/utils.py

@@ -1,9 +1,13 @@
 """Utility functions"""
 
+import threading
+
 from loguru import logger
 from safe_eth.eth import EthereumNetwork
 from safe_eth.safe.addresses import MASTER_COPIES, PROXY_FACTORIES
 
+_logger_lock = threading.Lock()
+
 
 def singleton(cls):
     """Singleton decorator to ensure a class has only one instance."""
@@ -54,37 +58,40 @@ def configure_logger():
     if hasattr(configure_logger, "configured"):
         return logger
 
-    import logging
+    with _logger_lock:
+        if hasattr(configure_logger, "configured"):  # double-checked locking
+            return logger
 
-    from iwa.core.constants import DATA_DIR
+        import logging
+        import sys
 
-    # Silence noisy third-party loggers (these use stdlib logging, not loguru)
-    logging.getLogger("apscheduler.scheduler").setLevel(logging.WARNING)
-    logging.getLogger("apscheduler.executors.default").setLevel(logging.WARNING)
-    logging.getLogger("httpx").setLevel(logging.WARNING)
+        from iwa.core.constants import DATA_DIR
 
-    logger.remove()
+        # Silence noisy third-party loggers (these use stdlib logging, not loguru)
+        logging.getLogger("apscheduler.scheduler").setLevel(logging.WARNING)
+        logging.getLogger("apscheduler.executors.default").setLevel(logging.WARNING)
+        logging.getLogger("httpx").setLevel(logging.WARNING)
 
-    # Ensure data directory exists
-    DATA_DIR.mkdir(parents=True, exist_ok=True)
+        logger.remove()
 
-    import sys
+        # Restore console logging (stderr) so logs are visible in docker/systemd/frontend streams
+        logger.add(sys.stderr, level="INFO")
 
-    logger.add(
-        DATA_DIR / "iwa.log",
-        rotation="10 MB",
-        level="INFO",
-        format="{time:YYYY-MM-DD HH:mm:ss.SSS} | {level: <8} | {name}:{function}:{line} - {message}",
-    )
+        # Attempt file logging; silently skip if the data dir isn't writable (e.g. read-only mounts)
+        try:
+            DATA_DIR.mkdir(parents=True, exist_ok=True)
+            logger.add(
+                DATA_DIR / "iwa.log",
+                rotation="10 MB",
+                level="INFO",
+                format="{time:YYYY-MM-DD HH:mm:ss.SSS} | {level: <8} | {name}:{function}:{line} - {message}",
+            )
+        except (PermissionError, OSError) as exc:
+            # Log only the exception type to avoid exposing system paths in warnings
+            logger.warning("iwa log file unavailable ({}), falling back to console-only logging", type(exc).__name__)
 
-    # Restore console logging (stderr) so logs are visible in docker/systemd/frontend streams
-    logger.add(sys.stderr, level="INFO")
-    # Also keep stderr for console if needed, but Textual captures it?
-    # Textual usually captures stderr. Writing to file is safer for debugging.
-    # Users previous logs show stdout format?
-
-    configure_logger.configured = True
-    return logger
+        configure_logger.configured = True
+        return logger
 
 
 def get_version(package_name: str) -> str:

src/tests/test_utils.py

@@ -1,8 +1,107 @@
+import sys
 from unittest.mock import patch
 
 import pytest
 
-from iwa.core.utils import get_safe_master_copy_address, singleton
+from iwa.core.utils import configure_logger, get_safe_master_copy_address, singleton
+
+
+@pytest.fixture
+def reset_configure_logger():
+    """Remove the configured flag so configure_logger can be called fresh in each test."""
+    had_flag = hasattr(configure_logger, "configured")
+    if had_flag:
+        delattr(configure_logger, "configured")
+    yield
+    # Restore flag state so other tests aren't affected
+    if hasattr(configure_logger, "configured"):
+        delattr(configure_logger, "configured")
+    if had_flag:
+        configure_logger.configured = True
+
+
+class TestConfigureLogger:
+    def test_happy_path(self, reset_configure_logger, tmp_path):
+        """File logging and stderr both succeed — stderr added first, then file."""
+        with (
+            patch("iwa.core.utils.logger") as mock_logger,
+            patch("iwa.core.constants.DATA_DIR", tmp_path),
+        ):
+            result = configure_logger()
+
+        mock_logger.remove.assert_called_once()
+        assert mock_logger.add.call_count == 2  # stderr + file
+        # Verify stderr is the first sink (order matters for fallback logic)
+        first_call_args = mock_logger.add.call_args_list[0]
+        assert first_call_args == ((sys.stderr,), {"level": "INFO"})
+        assert configure_logger.configured is True
+        assert result is mock_logger
+
+    def test_permission_error_on_mkdir(self, reset_configure_logger):
+        """PermissionError from mkdir → warning with type name, only stderr sink, no crash."""
+        with (
+            patch("iwa.core.utils.logger") as mock_logger,
+            patch("iwa.core.constants.DATA_DIR") as mock_data_dir,
+        ):
+            mock_data_dir.mkdir.side_effect = PermissionError("read-only file system")
+
+            configure_logger()
+
+        # Only stderr was added (mkdir failed before logger.add for file)
+        mock_logger.add.assert_called_once_with(sys.stderr, level="INFO")
+        mock_logger.warning.assert_called_once()
+        warning_msg = mock_logger.warning.call_args[0][0]
+        assert "unavailable" in warning_msg
+        assert configure_logger.configured is True
+
+    def test_oserror_on_mkdir(self, reset_configure_logger):
+        """OSError (e.g. disk full) from mkdir → same fallback as PermissionError."""
+        with (
+            patch("iwa.core.utils.logger") as mock_logger,
+            patch("iwa.core.constants.DATA_DIR") as mock_data_dir,
+        ):
+            mock_data_dir.mkdir.side_effect = OSError("no space left on device")
+
+            configure_logger()
+
+        mock_logger.add.assert_called_once_with(sys.stderr, level="INFO")
+        mock_logger.warning.assert_called_once()
+        assert "unavailable" in mock_logger.warning.call_args[0][0]
+        assert configure_logger.configured is True
+
+    def test_permission_error_on_file_add(self, reset_configure_logger):
+        """PermissionError from logger.add(file) → warning with type name, fallback to stderr."""
+        with (
+            patch("iwa.core.utils.logger") as mock_logger,
+            patch("iwa.core.constants.DATA_DIR") as mock_data_dir,
+        ):
+            mock_data_dir.mkdir.return_value = None
+            # First add (stderr) succeeds; second add (file) raises PermissionError
+            mock_logger.add.side_effect = [None, PermissionError("permission denied")]
+
+            configure_logger()
+
+        assert mock_logger.add.call_count == 2
+        mock_logger.warning.assert_called_once()
+        assert "unavailable" in mock_logger.warning.call_args[0][0]
+        assert configure_logger.configured is True
+
+    def test_configured_flag_prevents_reinit(self, reset_configure_logger):
+        """Second call to configure_logger() returns immediately without re-initializing."""
+        with (
+            patch("iwa.core.utils.logger") as mock_logger,
+            patch("iwa.core.constants.DATA_DIR") as mock_data_dir,
+        ):
+            mock_data_dir.mkdir.return_value = None
+            configure_logger()
+            # Verify first call did initialize
+            assert mock_logger.add.call_count >= 1
+            mock_logger.reset_mock()
+
+            configure_logger()
+
+        mock_logger.remove.assert_not_called()
+        mock_logger.add.assert_not_called()
 
 
 def test_get_safe_master_copy_address_found():