mmrelay 1.1.1__py3-none-any.whl → 1.1.3__py3-none-any.whl

mmrelay/__init__.py

@@ -2,16 +2,4 @@
 Meshtastic Matrix Relay - Bridge between Meshtastic mesh networks and Matrix chat rooms.
 """
 
-import os
-from importlib.metadata import PackageNotFoundError, version
-
-# First try to get version from environment variable (GitHub tag)
-if "GITHUB_REF_NAME" in os.environ:
-    __version__ = os.environ.get("GITHUB_REF_NAME")
-else:
-    # Fall back to package metadata using importlib.metadata (modern replacement for pkg_resources)
-    try:
-        __version__ = version("mmrelay")
-    except PackageNotFoundError:
-        # If all else fails, use hardcoded version
-        __version__ = "1.1.1"
+__version__ = "1.1.3"

mmrelay/log_utils.py

@@ -28,15 +28,52 @@ config = None
 # Global variable to store the log file path
 log_file_path = None
 
+# Track if component debug logging has been configured
+_component_debug_configured = False
+
+# Component logger mapping for data-driven configuration
+_COMPONENT_LOGGERS = {
+    "matrix_nio": ["nio", "nio.client", "nio.http", "nio.crypto"],
+    "bleak": ["bleak", "bleak.backends"],
+    "meshtastic": [
+        "meshtastic",
+        "meshtastic.serial_interface",
+        "meshtastic.tcp_interface",
+        "meshtastic.ble_interface",
+    ],
+}
+
+
+def configure_component_debug_logging():
+    """
+    Enables debug-level logging for selected external components based on configuration settings.
+
+    This function sets the log level to DEBUG for specific libraries (matrix_nio, bleak, meshtastic) if enabled in the global configuration under `logging.debug`. It ensures that component debug logging is configured only once per application run.
+    """
+    global _component_debug_configured, config
+
+    # Only configure once
+    if _component_debug_configured or config is None:
+        return
+
+    debug_config = config.get("logging", {}).get("debug", {})
+
+    for component, loggers in _COMPONENT_LOGGERS.items():
+        if debug_config.get(component, False):
+            for logger_name in loggers:
+                logging.getLogger(logger_name).setLevel(logging.DEBUG)
+
+    _component_debug_configured = True
+
 
 def get_logger(name):
     """
-    Create and configure a logger with console and optional file output, supporting colorized output and log rotation.
+    Create and configure a logger with console and optional rotating file output, using global configuration and command-line arguments.
 
-    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".
+    The logger supports colorized console output via Rich if enabled, and writes logs to a rotating file if configured or requested via command-line arguments. Log file location and rotation parameters are determined by priority: command-line argument, configuration file, or a default directory. The function ensures the log directory exists and stores the log file path globally if the logger name is "M<>M Relay".
 
     Parameters:
-        name (str): The name of the logger to create.
+        name (str): The name of the logger to create and configure.
 
     Returns:
         logging.Logger: The configured logger instance.
@@ -145,48 +182,3 @@ 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

@@ -4,6 +4,7 @@ It uses Meshtastic-python and Matrix nio client library to interface with the ra
 """
 
 import asyncio
+import concurrent.futures
 import logging
 import signal
 import sys
@@ -20,12 +21,18 @@ from mmrelay.db_utils import (
     update_shortnames,
     wipe_message_map,
 )
-from mmrelay.log_utils import get_logger, setup_upstream_logging_capture
+from mmrelay.log_utils import get_logger
 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
 from mmrelay.meshtastic_utils import connect_meshtastic
 from mmrelay.meshtastic_utils import logger as meshtastic_logger
+from mmrelay.message_queue import (
+    DEFAULT_MESSAGE_DELAY,
+    get_message_queue,
+    start_message_queue,
+    stop_message_queue,
+)
 from mmrelay.plugin_loader import load_plugins
 
 # Initialize logger
@@ -50,12 +57,9 @@ def print_banner():
 
 async def main(config):
     """
-    Sets up and runs the asynchronous relay between Meshtastic and Matrix, managing connections, event handling, and graceful shutdown.
-
-    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.
+    Runs the main asynchronous relay loop, managing the lifecycle and coordination between Meshtastic and Matrix clients.
 
-    Parameters:
-        config: The loaded configuration dictionary containing Matrix, Meshtastic, and database settings.
+    Initializes the database, loads plugins, starts the message queue, and establishes connections to both Meshtastic and Matrix. Joins configured Matrix rooms, registers event callbacks for message and membership events, and periodically updates node names from the Meshtastic network. Monitors connection health, manages the Matrix sync loop with reconnection and shutdown handling, and ensures graceful shutdown of all components, including optional message map wiping on startup and shutdown if configured.
     """
     # Extract Matrix configuration
     from typing import List
@@ -68,9 +72,6 @@ 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", {})
@@ -95,6 +96,12 @@ async def main(config):
     # Load plugins early
     load_plugins(passed_config=config)
 
+    # Start message queue with configured message delay
+    message_delay = config.get("meshtastic", {}).get(
+        "message_delay", DEFAULT_MESSAGE_DELAY
+    )
+    start_message_queue(message_delay=message_delay)
+
     # Connect to Meshtastic
     meshtastic_utils.meshtastic_client = connect_meshtastic(passed_config=config)
 
@@ -137,6 +144,9 @@ async def main(config):
     # This provides proactive connection detection for all interface types
     _ = asyncio.create_task(meshtastic_utils.check_connection())
 
+    # Ensure message queue processor is started now that event loop is running
+    get_message_queue().ensure_processor_started()
+
     # Start the Matrix client sync loop
     try:
         while not shutdown_event.is_set():
@@ -178,14 +188,39 @@ async def main(config):
         await shutdown()
     finally:
         # Cleanup
+        matrix_logger.info("Stopping message queue...")
+        stop_message_queue()
+
         matrix_logger.info("Closing Matrix client...")
         await matrix_client.close()
         if meshtastic_utils.meshtastic_client:
             meshtastic_logger.info("Closing Meshtastic client...")
             try:
-                meshtastic_utils.meshtastic_client.close()
+                # Timeout wrapper to prevent infinite hanging during shutdown
+                # The meshtastic library can sometimes hang indefinitely during close()
+                # operations, especially with BLE connections. This timeout ensures
+                # the application can shut down gracefully within 10 seconds.
+
+                def _close_meshtastic():
+                    """
+                    Closes the Meshtastic client connection synchronously.
+                    """
+                    meshtastic_utils.meshtastic_client.close()
+
+                with concurrent.futures.ThreadPoolExecutor(max_workers=1) as executor:
+                    future = executor.submit(_close_meshtastic)
+                    future.result(timeout=10.0)  # 10-second timeout
+
+                meshtastic_logger.info("Meshtastic client closed successfully")
+            except concurrent.futures.TimeoutError:
+                meshtastic_logger.warning(
+                    "Meshtastic client close timed out - forcing shutdown"
+                )
             except Exception as e:
-                meshtastic_logger.warning(f"Error closing Meshtastic client: {e}")
+                meshtastic_logger.error(
+                    f"Unexpected error during Meshtastic client close: {e}",
+                    exc_info=True,
+                )
 
         # Attempt to wipe message_map on shutdown if enabled
         if wipe_on_restart:
@@ -264,6 +299,9 @@ def run_main(args):
     set_config(db_utils, config)
     set_config(base_plugin, config)
 
+    # Configure component debug logging now that config is available
+    log_utils.configure_component_debug_logging()
+
     # Get config path and log file path for logging
     from mmrelay.config import config_path
     from mmrelay.log_utils import log_file_path