mmrelay 1.1.1__py3-none-any.whl → 1.1.2__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.1.1"
+        __version__ = "1.1.2"

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,7 +21,7 @@ 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
@@ -50,12 +51,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.
+    Run the main asynchronous relay loop, managing connections between Meshtastic and Matrix, 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.
-
-    Parameters:
-        config: The loaded configuration dictionary containing Matrix, Meshtastic, and database settings.
+    Initializes the database, loads plugins, connects to Meshtastic and Matrix, joins configured Matrix rooms, and registers event callbacks for message and membership events. Periodically updates node names from the Meshtastic network and manages the Matrix sync loop, handling reconnections and shutdown signals. If configured, wipes the message map on both startup and shutdown.
     """
     # Extract Matrix configuration
     from typing import List
@@ -68,9 +66,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", {})
@@ -183,9 +178,31 @@ async def main(config):
         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 +281,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

mmrelay/meshtastic_utils.py

@@ -47,18 +47,17 @@ reconnecting = False
 shutting_down = False
 reconnect_task = None  # To keep track of the reconnect task
 
-# Track pubsub subscription state to prevent duplicate subscriptions during reconnections
+# Subscription flags to prevent duplicate subscriptions
 subscribed_to_messages = False
 subscribed_to_connection_lost = False
-subscribed_to_connection_established = False
 
 
 def is_running_as_service():
     """
-    Check if the application is running as a systemd service.
-    
+    Determine if the application is running as a systemd service.
+
     Returns:
-        True if the process is running under systemd, either by detecting the INVOCATION_ID environment variable or by verifying that the parent process is systemd; otherwise, False.
+        bool: True if running under systemd (as indicated by the INVOCATION_ID environment variable or parent process), False otherwise.
     """
     # Check for INVOCATION_ID environment variable (set by systemd)
     if os.environ.get("INVOCATION_ID"):
@@ -89,16 +88,16 @@ def serial_port_exists(port_name):
 
 def connect_meshtastic(passed_config=None, force_connect=False):
     """
-    Establishes and manages a connection to a Meshtastic device using the specified connection type (serial, BLE, or TCP).
-    
-    If a configuration is provided, updates the global configuration and Matrix room mappings. Handles reconnection logic, including closing any existing connection if `force_connect` is True. Retries connection attempts with exponential backoff until successful or shutdown is initiated. Subscribes to message and connection events only once per process to avoid duplicate subscriptions.
-    
+    Establishes and manages a connection to a Meshtastic device using serial, BLE, or TCP, with automatic retries and event subscriptions.
+
+    If a configuration is provided, updates the global configuration and Matrix room mappings. If already connected and not forced, returns the existing client. Handles reconnection logic with exponential backoff, verifies serial port existence, and subscribes to message and connection lost events upon successful connection.
+
     Parameters:
-        passed_config (dict, optional): Configuration dictionary to use for the connection. If provided, updates the global configuration.
+        passed_config (dict, optional): Configuration dictionary to use for the connection.
         force_connect (bool, optional): If True, forces a new connection even if one already exists.
-    
+
     Returns:
-        Meshtastic interface client if the connection is successful, or None if the connection fails or shutdown is in progress.
+        meshtastic_client: The connected Meshtastic client instance, or None if connection fails or shutdown is in progress.
     """
     global meshtastic_client, shutting_down, config, matrix_rooms
     if shutting_down:
@@ -203,8 +202,8 @@ def connect_meshtastic(passed_config=None, force_connect=False):
                     f"Connected to {nodeInfo['user']['shortName']} / {nodeInfo['user']['hwModel']}"
                 )
 
-                # Subscribe to message and connection events (only if not already subscribed)
-                global subscribed_to_messages, subscribed_to_connection_lost, subscribed_to_connection_established
+                # Subscribe to message and connection lost events (only once per application run)
+                global subscribed_to_messages, subscribed_to_connection_lost
                 if not subscribed_to_messages:
                     pub.subscribe(on_meshtastic_message, "meshtastic.receive")
                     subscribed_to_messages = True
@@ -217,13 +216,6 @@ def connect_meshtastic(passed_config=None, force_connect=False):
                     subscribed_to_connection_lost = True
                     logger.debug("Subscribed to meshtastic.connection.lost")
 
-                if not subscribed_to_connection_established:
-                    pub.subscribe(
-                        on_established_meshtastic_connection, "meshtastic.connection.established"
-                    )
-                    subscribed_to_connection_established = True
-                    logger.debug("Subscribed to meshtastic.connection.established")
-
             except (
                 serial.SerialException,
                 BleakDBusError,
@@ -249,13 +241,13 @@ def connect_meshtastic(passed_config=None, force_connect=False):
     return meshtastic_client
 
 
-def on_lost_meshtastic_connection(interface=None, detection_source="detected by library"):
+def on_lost_meshtastic_connection(interface=None, detection_source="unknown"):
     """
-    Handles Meshtastic connection loss by initiating a reconnection sequence unless a shutdown is in progress or a reconnection is already underway.
-    
-    Parameters:
-        interface: The interface that lost connection (unused; present for compatibility).
-        detection_source (str): Description of how the disconnection was detected.
+    Handles loss of Meshtastic connection by initiating a reconnection sequence unless the system is shutting down or already reconnecting.
+
+    Args:
+        interface: The Meshtastic interface (optional, for compatibility)
+        detection_source: Source that detected the connection loss (for debugging)
     """
     global meshtastic_client, reconnecting, shutting_down, event_loop, reconnect_task
     with meshtastic_lock:
@@ -290,8 +282,8 @@ def on_lost_meshtastic_connection(interface=None, detection_source="detected by
 async def reconnect():
     """
     Asynchronously attempts to reconnect to the Meshtastic device using exponential backoff, stopping if a shutdown is initiated.
-    
-    The function increases the wait time between attempts up to a maximum of 5 minutes and provides a progress bar if not running as a service. The reconnection process halts immediately if the shutdown flag is set or if reconnection succeeds.
+
+    Reconnection attempts start with a 10-second delay, doubling up to a maximum of 5 minutes between attempts. If not running as a service, a progress bar is displayed during the wait. The process stops immediately if `shutting_down` is set to True or upon successful reconnection.
     """
     global meshtastic_client, reconnecting, shutting_down
     backoff_time = 10
@@ -346,23 +338,11 @@ async def reconnect():
         reconnecting = False
 
 
-def on_established_meshtastic_connection(interface=None):
-    """
-    Callback triggered when a Meshtastic connection is successfully established.
-    
-    Clears the reconnecting flag and logs the connection event.
-    """
-    global reconnecting
-    with meshtastic_lock:
-        logger.info("Connection established (detected by library)")
-        reconnecting = False  # Clear reconnecting flag when connection is confirmed
-
-
 def on_meshtastic_message(packet, interface):
     """
-    Process incoming Meshtastic messages and relay them to Matrix rooms or plugins according to message type and interaction settings.
-    
-    Handles reactions and replies by relaying them to Matrix if enabled. Normal text messages are relayed to all mapped Matrix rooms unless handled by a plugin or directed to the relay node. Non-text messages are passed to plugins for processing. Messages from unmapped channels or disabled detection sensors are filtered out, and sender information is retrieved or stored as needed.
+    Process incoming Meshtastic messages and relay them to Matrix rooms or plugins according to message type and configuration.
+
+    Handles reactions and replies by relaying them to Matrix if enabled. Normal text messages are relayed to all mapped Matrix rooms unless handled by a plugin or directed to the relay node. Non-text messages are passed to plugins for processing. Messages from unmapped channels or disabled detection sensors are ignored. Ensures sender information is retrieved or stored as needed.
     """
     global config, matrix_rooms
 
@@ -667,28 +647,42 @@ def on_meshtastic_message(packet, interface):
 
 async def check_connection():
     """
-    Periodically verifies the health of the Meshtastic connection and triggers reconnection if needed.
-    
-    For non-BLE connections, this coroutine calls `localNode.getMetadata()` at a configurable interval to confirm the connection is alive. If the health check fails or does not return expected metadata, it invokes the connection lost handler to initiate reconnection. BLE connections are excluded from periodic checks, as their library provides real-time disconnection detection.
-    
-    This coroutine runs continuously until shutdown is requested.
+    Periodically checks the health of the Meshtastic connection and triggers reconnection if the connection is lost.
+
+    Health checks can be enabled/disabled via configuration. When enabled, for non-BLE connections,
+    invokes `localNode.getMetadata()` at configurable intervals (default 60 seconds) to verify connectivity.
+    If the check fails or the firmware version is missing, initiates reconnection logic.
+
+    BLE connections rely on real-time disconnection detection and skip periodic health checks.
+    The function runs continuously until shutdown is requested.
+
+    Configuration:
+        health_check.enabled: Enable/disable health checks (default: true)
+        health_check.heartbeat_interval: Interval between checks in seconds (default: 60)
     """
-    global meshtastic_client, shutting_down, config, reconnecting
+    global meshtastic_client, shutting_down, config
 
     # Check if config is available
     if config is None:
         logger.error("No configuration available. Cannot check connection.")
         return
 
-    # Get heartbeat interval from config, default to 180 seconds
-    heartbeat_interval = config["meshtastic"].get("heartbeat_interval", 180)
     connection_type = config["meshtastic"]["connection_type"]
 
-    logger.info(
-        f"Starting connection heartbeat monitor (interval: {heartbeat_interval}s)"
-    )
+    # Get health check configuration
+    health_config = config["meshtastic"].get("health_check", {})
+    health_check_enabled = health_config.get("enabled", True)
+    heartbeat_interval = health_config.get("heartbeat_interval", 60)
+
+    # Support legacy heartbeat_interval configuration for backward compatibility
+    if "heartbeat_interval" in config["meshtastic"]:
+        heartbeat_interval = config["meshtastic"]["heartbeat_interval"]
+
+    # Exit early if health checks are disabled
+    if not health_check_enabled:
+        logger.info("Connection health checks are disabled in configuration")
+        return
 
-    # Track if we've logged the BLE skip message to avoid spam
     ble_skip_logged = False
 
     while not shutting_down:
@@ -697,13 +691,12 @@ async def check_connection():
             # Skip periodic health checks to avoid duplicate reconnection attempts
             if connection_type == "ble":
                 if not ble_skip_logged:
-                    logger.info("BLE connection uses real-time disconnection detection - health checks disabled")
+                    logger.info(
+                        "BLE connection uses real-time disconnection detection - health checks disabled"
+                    )
                     ble_skip_logged = True
             else:
                 try:
-                    logger.debug(
-                        f"Checking {connection_type} connection health using getMetadata()"
-                    )
                     output_capture = io.StringIO()
                     with contextlib.redirect_stdout(
                         output_capture
@@ -714,18 +707,20 @@ async def check_connection():
                     if "firmware_version" not in console_output:
                         raise Exception("No firmware_version in getMetadata output.")
 
-                    logger.debug(f"{connection_type.capitalize()} connection healthy")
-
                 except Exception as e:
                     # Only trigger reconnection if we're not already reconnecting
                     if not reconnecting:
-                        logger.warning(
+                        logger.error(
                             f"{connection_type.capitalize()} connection health check failed: {e}"
                         )
-                        # Use existing handler with health check reason
-                        on_lost_meshtastic_connection(detection_source=f"health check failed: {str(e)}")
+                        on_lost_meshtastic_connection(
+                            interface=meshtastic_client,
+                            detection_source=f"health check failed: {str(e)}",
+                        )
                     else:
-                        logger.debug("Skipping reconnection trigger - already reconnecting")
+                        logger.debug(
+                            "Skipping reconnection trigger - already reconnecting"
+                        )
         elif reconnecting:
             logger.debug("Skipping connection check - reconnection in progress")
         elif not meshtastic_client:
@@ -743,21 +738,20 @@ def sendTextReply(
     channelIndex: int = 0,
 ):
     """
-    Send a text message as a reply to a previous message.
+    Send a Meshtastic text message as a reply to a specific previous message.
 
-    This function creates a proper Meshtastic reply by setting the reply_id field
-    in the Data protobuf message, which the standard sendText() method doesn't support.
+    Creates and sends a reply message by setting the `reply_id` field in the Meshtastic Data protobuf, enabling proper reply threading. Returns the sent packet with its ID populated.
 
-    Args:
-        interface: The Meshtastic interface to send through
-        text: The text message to send
-        reply_id: The ID of the message this is replying to
-        destinationId: Where to send the message (default: broadcast)
-        wantAck: Whether to request acknowledgment
-        channelIndex: Which channel to send on
+    Parameters:
+        interface: The Meshtastic interface to send through.
+        text (str): The message content to send.
+        reply_id (int): The ID of the message being replied to.
+        destinationId: The recipient address (defaults to broadcast).
+        wantAck (bool): Whether to request acknowledgment for the message.
+        channelIndex (int): The channel index to send the message on.
 
     Returns:
-        The sent packet with populated ID field
+        The sent MeshPacket with its ID field populated.
     """
     logger.debug(f"Sending text reply: '{text}' replying to message ID {reply_id}")
 

mmrelay/tools/sample_config.yaml

@@ -18,11 +18,17 @@ meshtastic:
   broadcast_enabled: true # Must be set to true to enable Matrix to Meshtastic messages
   detection_sensor: true # Must be set to true to forward messages of Meshtastic's detection sensor module
   plugin_response_delay: 3 # Default response delay in seconds for plugins that respond on the mesh;
-  # heartbeat_interval: 180 # Interval in seconds to check connection health using getMetadata() (default: 180)
   message_interactions: # Configure reactions and replies (both require message storage in database)
     reactions: false # Enable reaction relaying between platforms
     replies: false   # Enable reply relaying between platforms
 
+  # Connection health monitoring configuration
+  #health_check:
+  #  enabled: true                    # Enable/disable periodic health checks (default: true)
+  #  heartbeat_interval: 60           # Interval in seconds between health checks (default: 60)
+  #                                   # Note: BLE connections use real-time disconnection detection and skip periodic checks
+  #                                   # Legacy: heartbeat_interval at meshtastic level still supported but deprecated
+
 logging:
   level: info
   #log_to_file: true                          # Set to true to enable file logging
@@ -31,6 +37,12 @@ logging:
   #backup_count: 1                            # Keeps 1 backup as the default if omitted
   #color_enabled: true                        # Set to false to disable colored console output
 
+  # Component-specific debug logging (useful for troubleshooting)
+  #debug:
+  #  matrix_nio: false                         # Enable matrix-nio debug logging for Matrix client issues
+  #  bleak: false                              # Enable BLE (bleak) debug logging for Bluetooth connection issues
+  #  meshtastic: false                         # Enable meshtastic library debug logging for device communication issues
+
 #database:
 #  path: ~/.mmrelay/data/meshtastic.sqlite   # Default location
 #  msg_map: # The message map is necessary for the relay_reactions functionality. If `relay_reactions` is set to false, nothing will be saved to the message map.

{mmrelay-1.1.1.dist-info → mmrelay-1.1.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mmrelay
-Version: 1.1.1
+Version: 1.1.2
 Summary: Bridge between Meshtastic mesh networks and Matrix chat rooms
 Home-page: https://github.com/geoffwhittington/meshtastic-matrix-relay
 Author: Geoff Whittington, Jeremiah K., and contributors
@@ -173,5 +173,5 @@ See our Wiki page [Getting Started With Matrix & MM Relay](https://github.com/ge
 Join us!
 
 - Our project's room: [#mmrelay:matrix.org](https://matrix.to/#/#mmrelay:matrix.org)
-- Part of the Meshtastic Community Matrix space: [#meshnetclub:matrix.org](https://matrix.to/#/#meshnetclub:matrix.org)
+- Part of the Meshnet Club Matrix space: [#meshnetclub:matrix.org](https://matrix.to/#/#meshnetclub:matrix.org)
 - Public Relay Room: [#mmrelay-relay-room:matrix.org](https://matrix.to/#/#mmrelay-relay-room:matrix.org) - Where we bridge multiple meshnets. Feel free to join us, with or without a relay!

{mmrelay-1.1.1.dist-info → mmrelay-1.1.2.dist-info}/RECORD

@@ -1,12 +1,12 @@
-mmrelay/__init__.py,sha256=v-xcK3JoA0m2eBmIudme82RPgp5PQInzRSs5mitHB28,594
+mmrelay/__init__.py,sha256=ofK1VtDZwWBsSvfj0gcmsvkTTVHq_Go5MpGdU5NxdHM,594
 mmrelay/cli.py,sha256=hdPTlcGsXTJC9GEUiScG7b3IFp02B3lwhqgwFpU3NsM,13835
 mmrelay/config.py,sha256=5VZag8iSc5yLQgvwI76bbpizbtqag74cHnfXCrWHNyA,7910
 mmrelay/config_checker.py,sha256=UnoHVTXzfdTfFkbmXv9r_Si76v-sxXLb5FOaQSOM45E,4909
 mmrelay/db_utils.py,sha256=eTMMkYVWsmO_DkrBfnZMw4ohg_xa0S9TXJoBjRFTwzo,13590
-mmrelay/log_utils.py,sha256=ot0GpYppyNuPOWY8d3EXdLPojoJYEqfmUjVlcYm8neY,7532
-mmrelay/main.py,sha256=TL5xWFXIGwAQKau-hN4sRB0wxtNWzc629ry_qPbovv0,11585
+mmrelay/log_utils.py,sha256=1zVHBJ5qSOG1O4cq4Ebngq9dp81vaZOEq5khulAFuuM,6611
+mmrelay/main.py,sha256=-usvB02bl4ubwQ4obUzncV-5pKTRaplfOvvKcVNWBK8,12493
 mmrelay/matrix_utils.py,sha256=XSOHztRrdIjFGyYt8QhGBL6nMv_6iodeYL288pG9voA,45813
-mmrelay/meshtastic_utils.py,sha256=MgCNGSufQDddncVKJVgmp_6DDZbcHSvOvW72vuNDLeg,31596
+mmrelay/meshtastic_utils.py,sha256=9H5kt7X5KXx8FvnWm4fU-CVoFq35JjE-YQC2j98Miq0,31012
 mmrelay/plugin_loader.py,sha256=NRiXF6Ty1WD9jNXXKvzJh7kE0ba5oICXNVAfMaTPqH4,39247
 mmrelay/setup_utils.py,sha256=N6qdScHKHEMFKDmT1l7dcLDPNTusZXPkyxrLXjFLhRI,19910
 mmrelay/plugins/__init__.py,sha256=KVMQIXRhe0wlGj4O3IZ0vOIQRKFkfPYejHXhJL17qrc,51
@@ -25,10 +25,10 @@ mmrelay/tools/__init__.py,sha256=WFjDQjdevgg19_zT6iEoL29rvb1JPqYSd8708Jn5D7A,838
 mmrelay/tools/mmrelay.service,sha256=3vqK1VbfXvVftkTrTEOan77aTHeOT36hIAL7HqJsmTg,567
 mmrelay/tools/sample-docker-compose.yaml,sha256=vVgJrh-6l48hkj5F-52JA5tpDWPBjiPQ36CE9Pkqn44,1251
 mmrelay/tools/sample.env,sha256=RP-o3rX3jnEIrVG2rqCZq31O1yRXou4HcGrXWLVbKKw,311
-mmrelay/tools/sample_config.yaml,sha256=0BKND0qbke8z9X9J9iHleu567dZt3RmHUxhZlQEEdFk,3290
-mmrelay-1.1.1.dist-info/licenses/LICENSE,sha256=yceWauM1c0-FHxVplsD7W1-AbSeRaUNlmqT4UO1msBU,1073
-mmrelay-1.1.1.dist-info/METADATA,sha256=ltSYRsnKQvdwsKd0CqAqMoSMWLsqZq8Pcpmfy_OjqI8,6713
-mmrelay-1.1.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-mmrelay-1.1.1.dist-info/entry_points.txt,sha256=SJZwGUOEpQ-qx4H8UL4xKFnKeInGUaZNW1I0ddjK7Ws,45
-mmrelay-1.1.1.dist-info/top_level.txt,sha256=B_ZLCRm7NYAmI3PipRUyHGymP-C-q16LSeMGzmqJfo4,8
-mmrelay-1.1.1.dist-info/RECORD,,
+mmrelay/tools/sample_config.yaml,sha256=57LkzZUuCFNmfLzeBn9Vs1rtZ_DLdwjWLjiH3-bN6GY,4094
+mmrelay-1.1.2.dist-info/licenses/LICENSE,sha256=yceWauM1c0-FHxVplsD7W1-AbSeRaUNlmqT4UO1msBU,1073
+mmrelay-1.1.2.dist-info/METADATA,sha256=OeWp6ooATRMHmJuFjpdYHtKLZioC03-GYU2ci5WnFOg,6705
+mmrelay-1.1.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+mmrelay-1.1.2.dist-info/entry_points.txt,sha256=SJZwGUOEpQ-qx4H8UL4xKFnKeInGUaZNW1I0ddjK7Ws,45
+mmrelay-1.1.2.dist-info/top_level.txt,sha256=B_ZLCRm7NYAmI3PipRUyHGymP-C-q16LSeMGzmqJfo4,8
+mmrelay-1.1.2.dist-info/RECORD,,