mmrelay 1.0.10__py3-none-any.whl → 1.1.0__py3-none-any.whl

mmrelay/__init__.py

@@ -14,4 +14,4 @@ else:
         __version__ = version("mmrelay")
     except PackageNotFoundError:
         # If all else fails, use hardcoded version
-        __version__ = "1.0.10"
+        __version__ = "1.1.0"

mmrelay/db_utils.py

@@ -8,17 +8,57 @@ from mmrelay.log_utils import get_logger
 # Global config variable that will be set from main.py
 config = None
 
+# Cache for database path to avoid repeated logging and path resolution
+_cached_db_path = None
+_db_path_logged = False
+_cached_config_hash = None
+
 logger = get_logger(name="db_utils")
 
 
+def clear_db_path_cache():
+    """Clear the cached database path to force re-resolution on next call.
+
+    This is useful for testing or if the application supports runtime
+    configuration changes.
+    """
+    global _cached_db_path, _db_path_logged, _cached_config_hash
+    _cached_db_path = None
+    _db_path_logged = False
+    _cached_config_hash = None
+
+
 # Get the database path
 def get_db_path():
     """
-    Returns the path to the SQLite database file.
-    By default, uses the standard data directory (~/.mmrelay/data).
-    Can be overridden by setting 'path' under 'database' in config.yaml.
+    Resolve and return the file path to the SQLite database, using configuration overrides if provided.
+
+    By default, returns the path to `meshtastic.sqlite` in the standard data directory (`~/.mmrelay/data`).
+    If a custom path is specified in the configuration under `database.path` (preferred) or `db.path` (legacy),
+    that path is used instead. The resolved path is cached for subsequent calls, and the directory is created
+    if it does not exist. Cache is automatically invalidated if the relevant configuration changes.
     """
-    global config
+    global config, _cached_db_path, _db_path_logged, _cached_config_hash
+
+    # Create a hash of the relevant config sections to detect changes
+    current_config_hash = None
+    if config is not None:
+        # Hash only the database-related config sections
+        db_config = {
+            "database": config.get("database", {}),
+            "db": config.get("db", {}),  # Legacy format
+        }
+        current_config_hash = hash(str(sorted(db_config.items())))
+
+    # Check if cache is valid (path exists and config hasn't changed)
+    if _cached_db_path is not None and current_config_hash == _cached_config_hash:
+        return _cached_db_path
+
+    # Config changed or first call - clear cache and re-resolve
+    if current_config_hash != _cached_config_hash:
+        _cached_db_path = None
+        _db_path_logged = False
+        _cached_config_hash = current_config_hash
 
     # Check if config is available
     if config is not None:
@@ -30,7 +70,12 @@ def get_db_path():
                 db_dir = os.path.dirname(custom_path)
                 if db_dir:
                     os.makedirs(db_dir, exist_ok=True)
-                logger.info(f"Using database path from config: {custom_path}")
+
+                # Cache the path and log only once
+                _cached_db_path = custom_path
+                if not _db_path_logged:
+                    logger.info(f"Using database path from config: {custom_path}")
+                    _db_path_logged = True
                 return custom_path
 
         # Check legacy format (db section)
@@ -41,13 +86,20 @@ def get_db_path():
                 db_dir = os.path.dirname(custom_path)
                 if db_dir:
                     os.makedirs(db_dir, exist_ok=True)
-                logger.warning(
-                    "Using 'db.path' configuration (legacy). 'database.path' is now the preferred format and 'db.path' will be deprecated in a future version."
-                )
+
+                # Cache the path and log only once
+                _cached_db_path = custom_path
+                if not _db_path_logged:
+                    logger.warning(
+                        "Using 'db.path' configuration (legacy). 'database.path' is now the preferred format and 'db.path' will be deprecated in a future version."
+                    )
+                    _db_path_logged = True
                 return custom_path
 
     # Use the standard data directory
-    return os.path.join(get_data_dir(), "meshtastic.sqlite")
+    default_path = os.path.join(get_data_dir(), "meshtastic.sqlite")
+    _cached_db_path = default_path
+    return default_path
 
 
 # Initialize SQLite database

mmrelay/log_utils.py

@@ -30,6 +30,17 @@ log_file_path = None
 
 
 def get_logger(name):
+    """
+    Create and configure a logger with console and optional file output, supporting colorized output and log rotation.
+
+    The logger's level, color usage, and file logging behavior are determined by global configuration and command line arguments. Console output uses rich formatting if enabled. File logging supports log rotation and stores logs in a configurable or default location. The log file path is stored globally if the logger name is "M<>M Relay".
+
+    Parameters:
+        name (str): The name of the logger to create.
+
+    Returns:
+        logging.Logger: The configured logger instance.
+    """
     logger = logging.getLogger(name=name)
 
     # Default to INFO level if config is not available
@@ -134,3 +145,48 @@ def get_logger(name):
         logger.addHandler(file_handler)
 
     return logger
+
+
+def setup_upstream_logging_capture():
+    """
+    Redirects warning and error log messages from upstream libraries and the root logger into the application's formatted logging system.
+
+    This ensures that log output from external dependencies (such as "meshtastic", "bleak", and "asyncio") appears with consistent formatting alongside the application's own logs. Only messages at WARNING level or higher are captured, and messages originating from the application's own loggers are excluded to prevent recursion.
+    """
+    # Get our main logger
+    main_logger = get_logger("Upstream")
+
+    # Create a custom handler that redirects root logger messages
+    class UpstreamLogHandler(logging.Handler):
+        def emit(self, record):
+            # Skip if this is already from our logger to avoid recursion
+            """
+            Redirects log records from external sources to the main logger, mapping their severity and prefixing with the original logger name.
+
+            Skips records originating from the application's own loggers to prevent recursion.
+            """
+            if record.name.startswith("mmrelay") or record.name == "Upstream":
+                return
+
+            # Map the log level and emit through our logger
+            if record.levelno >= logging.ERROR:
+                main_logger.error(f"[{record.name}] {record.getMessage()}")
+            elif record.levelno >= logging.WARNING:
+                main_logger.warning(f"[{record.name}] {record.getMessage()}")
+            elif record.levelno >= logging.INFO:
+                main_logger.info(f"[{record.name}] {record.getMessage()}")
+            else:
+                main_logger.debug(f"[{record.name}] {record.getMessage()}")
+
+    # Add our handler to the root logger
+    root_logger = logging.getLogger()
+    upstream_handler = UpstreamLogHandler()
+    upstream_handler.setLevel(logging.WARNING)  # Only capture warnings and errors
+    root_logger.addHandler(upstream_handler)
+
+    # Also set up specific loggers for known upstream libraries
+    for logger_name in ["meshtastic", "bleak", "asyncio"]:
+        upstream_logger = logging.getLogger(logger_name)
+        upstream_logger.addHandler(upstream_handler)
+        upstream_logger.setLevel(logging.WARNING)
+        upstream_logger.propagate = False  # Prevent duplicate messages via root logger

mmrelay/main.py

@@ -20,7 +20,7 @@ from mmrelay.db_utils import (
     update_shortnames,
     wipe_message_map,
 )
-from mmrelay.log_utils import get_logger
+from mmrelay.log_utils import get_logger, setup_upstream_logging_capture
 from mmrelay.matrix_utils import connect_matrix, join_matrix_room
 from mmrelay.matrix_utils import logger as matrix_logger
 from mmrelay.matrix_utils import on_room_member, on_room_message
@@ -50,13 +50,12 @@ def print_banner():
 
 async def main(config):
     """
-    Main asynchronous function to set up and run the relay.
-    Includes logic for wiping the message_map if configured in database.msg_map.wipe_on_restart
-    or db.msg_map.wipe_on_restart (legacy format).
-    Also updates longnames and shortnames periodically as before.
+    Sets up and runs the asynchronous relay between Meshtastic and Matrix, managing connections, event handling, and graceful shutdown.
 
-    Args:
-        config: The loaded configuration
+    This function initializes the database, configures logging, loads plugins, connects to both Meshtastic and Matrix, joins specified Matrix rooms, and registers event callbacks for message and membership events. It periodically updates node names from the Meshtastic network and manages the Matrix sync loop, handling reconnections and shutdown signals. If configured, it wipes the message map on startup and shutdown.
+
+    Parameters:
+        config: The loaded configuration dictionary containing Matrix, Meshtastic, and database settings.
     """
     # Extract Matrix configuration
     from typing import List
@@ -69,6 +68,9 @@ async def main(config):
     # Initialize the SQLite database
     initialize_database()
 
+    # Set up upstream logging capture to format library messages consistently
+    setup_upstream_logging_capture()
+
     # Check database config for wipe_on_restart (preferred format)
     database_config = config.get("database", {})
     msg_map_config = database_config.get("msg_map", {})
@@ -131,11 +133,8 @@ async def main(config):
         # On Windows, we can't use add_signal_handler, so we'll handle KeyboardInterrupt
         pass
 
-    # -------------------------------------------------------------------
-    # IMPORTANT: We create a task to run the meshtastic_utils.check_connection()
-    # so its while loop runs in parallel with the matrix sync loop
-    # Use "_" to avoid trunk's "assigned but unused variable" warning
-    # -------------------------------------------------------------------
+    # Start connection health monitoring using getMetadata() heartbeat
+    # This provides proactive connection detection for all interface types
     _ = asyncio.create_task(meshtastic_utils.check_connection())
 
     # Start the Matrix client sync loop