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

mmrelay/db_utils.py

@@ -31,12 +31,9 @@ def clear_db_path_cache():
 # Get the database path
 def get_db_path():
     """
-    Resolve and return the file path to the SQLite database, using configuration overrides if provided.
+    Resolves and returns 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.
+    Prefers the path specified in `config["database"]["path"]`, falls back to `config["db"]["path"]` (legacy), and defaults to `meshtastic.sqlite` in the standard data directory if neither is set. The resolved path is cached and the cache is invalidated if relevant configuration changes. Attempts to create the directory for the database path if it does not exist.
     """
     global config, _cached_db_path, _db_path_logged, _cached_config_hash
 
@@ -69,7 +66,13 @@ def get_db_path():
                 # Ensure the directory exists
                 db_dir = os.path.dirname(custom_path)
                 if db_dir:
-                    os.makedirs(db_dir, exist_ok=True)
+                    try:
+                        os.makedirs(db_dir, exist_ok=True)
+                    except (OSError, PermissionError) as e:
+                        logger.warning(
+                            f"Could not create database directory {db_dir}: {e}"
+                        )
+                        # Continue anyway - the database connection will fail later if needed
 
                 # Cache the path and log only once
                 _cached_db_path = custom_path
@@ -104,76 +107,128 @@ def get_db_path():
 
 # Initialize SQLite database
 def initialize_database():
+    """
+    Initializes the SQLite database schema for the relay application.
+
+    Creates required tables (`longnames`, `shortnames`, `plugin_data`, and `message_map`) if they do not exist, and ensures the `meshtastic_meshnet` column is present in `message_map`. Raises an exception if database initialization fails.
+    """
     db_path = get_db_path()
     # Check if database exists
     if os.path.exists(db_path):
         logger.info(f"Loading database from: {db_path}")
     else:
         logger.info(f"Creating new database at: {db_path}")
-    with sqlite3.connect(db_path) as conn:
-        cursor = conn.cursor()
-        # Updated table schema: matrix_event_id is now PRIMARY KEY, meshtastic_id is not necessarily unique
-        cursor.execute(
-            "CREATE TABLE IF NOT EXISTS longnames (meshtastic_id TEXT PRIMARY KEY, longname TEXT)"
-        )
-        cursor.execute(
-            "CREATE TABLE IF NOT EXISTS shortnames (meshtastic_id TEXT PRIMARY KEY, shortname TEXT)"
-        )
-        cursor.execute(
-            "CREATE TABLE IF NOT EXISTS plugin_data (plugin_name TEXT, meshtastic_id TEXT, data TEXT, PRIMARY KEY (plugin_name, meshtastic_id))"
-        )
-        # Changed the schema for message_map: matrix_event_id is now primary key
-        # Added a new column 'meshtastic_meshnet' to store the meshnet origin of the message.
-        # If table already exists, we try adding the column if it doesn't exist.
-        cursor.execute(
-            "CREATE TABLE IF NOT EXISTS message_map (meshtastic_id INTEGER, matrix_event_id TEXT PRIMARY KEY, matrix_room_id TEXT, meshtastic_text TEXT, meshtastic_meshnet TEXT)"
-        )
-
-        # Attempt to add meshtastic_meshnet column if it's missing (for upgrades)
-        # This is a no-op if the column already exists.
-        # If user runs fresh, it will already be there from CREATE TABLE IF NOT EXISTS.
-        try:
-            cursor.execute("ALTER TABLE message_map ADD COLUMN meshtastic_meshnet TEXT")
-        except sqlite3.OperationalError:
-            # Column already exists, or table just created with it
-            pass
+    try:
+        with sqlite3.connect(db_path) as conn:
+            cursor = conn.cursor()
+            # Updated table schema: matrix_event_id is now PRIMARY KEY, meshtastic_id is not necessarily unique
+            cursor.execute(
+                "CREATE TABLE IF NOT EXISTS longnames (meshtastic_id TEXT PRIMARY KEY, longname TEXT)"
+            )
+            cursor.execute(
+                "CREATE TABLE IF NOT EXISTS shortnames (meshtastic_id TEXT PRIMARY KEY, shortname TEXT)"
+            )
+            cursor.execute(
+                "CREATE TABLE IF NOT EXISTS plugin_data (plugin_name TEXT, meshtastic_id TEXT, data TEXT, PRIMARY KEY (plugin_name, meshtastic_id))"
+            )
+            # Changed the schema for message_map: matrix_event_id is now primary key
+            # Added a new column 'meshtastic_meshnet' to store the meshnet origin of the message.
+            # If table already exists, we try adding the column if it doesn't exist.
+            cursor.execute(
+                "CREATE TABLE IF NOT EXISTS message_map (meshtastic_id INTEGER, matrix_event_id TEXT PRIMARY KEY, matrix_room_id TEXT, meshtastic_text TEXT, meshtastic_meshnet TEXT)"
+            )
 
-        conn.commit()
+            # Attempt to add meshtastic_meshnet column if it's missing (for upgrades)
+            # This is a no-op if the column already exists.
+            # If user runs fresh, it will already be there from CREATE TABLE IF NOT EXISTS.
+            try:
+                cursor.execute(
+                    "ALTER TABLE message_map ADD COLUMN meshtastic_meshnet TEXT"
+                )
+            except sqlite3.OperationalError:
+                # Column already exists, or table just created with it
+                pass
+    except sqlite3.Error as e:
+        logger.error(f"Database initialization failed: {e}")
+        raise
 
 
 def store_plugin_data(plugin_name, meshtastic_id, data):
-    with sqlite3.connect(get_db_path()) as conn:
-        cursor = conn.cursor()
-        cursor.execute(
-            "INSERT OR REPLACE INTO plugin_data (plugin_name, meshtastic_id, data) VALUES (?, ?, ?) ON CONFLICT (plugin_name, meshtastic_id) DO UPDATE SET data = ?",
-            (plugin_name, meshtastic_id, json.dumps(data), json.dumps(data)),
+    """
+    Store or update JSON-serialized plugin data for a specific plugin and Meshtastic ID in the database.
+
+    Parameters:
+        plugin_name (str): The name of the plugin.
+        meshtastic_id (str): The Meshtastic node identifier.
+        data (Any): The plugin data to be serialized and stored.
+    """
+    try:
+        with sqlite3.connect(get_db_path()) as conn:
+            cursor = conn.cursor()
+            cursor.execute(
+                "INSERT OR REPLACE INTO plugin_data (plugin_name, meshtastic_id, data) VALUES (?, ?, ?) ON CONFLICT (plugin_name, meshtastic_id) DO UPDATE SET data = ?",
+                (plugin_name, meshtastic_id, json.dumps(data), json.dumps(data)),
+            )
+            conn.commit()
+    except sqlite3.Error as e:
+        logger.error(
+            f"Database error storing plugin data for {plugin_name}, {meshtastic_id}: {e}"
         )
-        conn.commit()
 
 
 def delete_plugin_data(plugin_name, meshtastic_id):
-    with sqlite3.connect(get_db_path()) as conn:
-        cursor = conn.cursor()
-        cursor.execute(
-            "DELETE FROM plugin_data WHERE plugin_name=? AND meshtastic_id=?",
-            (plugin_name, meshtastic_id),
+    """
+    Deletes the plugin data entry for the specified plugin and Meshtastic ID from the database.
+
+    Parameters:
+        plugin_name (str): The name of the plugin whose data should be deleted.
+        meshtastic_id (str): The Meshtastic node ID associated with the plugin data.
+    """
+    try:
+        with sqlite3.connect(get_db_path()) as conn:
+            cursor = conn.cursor()
+            cursor.execute(
+                "DELETE FROM plugin_data WHERE plugin_name=? AND meshtastic_id=?",
+                (plugin_name, meshtastic_id),
+            )
+            conn.commit()
+    except sqlite3.Error as e:
+        logger.error(
+            f"Database error deleting plugin data for {plugin_name}, {meshtastic_id}: {e}"
         )
-        conn.commit()
 
 
 # Get the data for a given plugin and Meshtastic ID
 def get_plugin_data_for_node(plugin_name, meshtastic_id):
-    with sqlite3.connect(get_db_path()) as conn:
-        cursor = conn.cursor()
-        cursor.execute(
-            "SELECT data FROM plugin_data WHERE plugin_name=? AND meshtastic_id=?",
-            (
-                plugin_name,
-                meshtastic_id,
-            ),
+    """
+    Retrieve and decode plugin data for a specific plugin and Meshtastic node.
+
+    Returns:
+        list: The deserialized plugin data as a list, or an empty list if no data is found or on error.
+    """
+    try:
+        with sqlite3.connect(get_db_path()) as conn:
+            cursor = conn.cursor()
+            cursor.execute(
+                "SELECT data FROM plugin_data WHERE plugin_name=? AND meshtastic_id=?",
+                (
+                    plugin_name,
+                    meshtastic_id,
+                ),
+            )
+            result = cursor.fetchone()
+        try:
+            return json.loads(result[0] if result else "[]")
+        except (json.JSONDecodeError, TypeError) as e:
+            logger.error(
+                f"Failed to decode JSON data for plugin {plugin_name}, node {meshtastic_id}: {e}"
+            )
+            return []
+    except (MemoryError, sqlite3.Error) as e:
+        logger.error(
+            f"Database error retrieving plugin data for {plugin_name}, node {meshtastic_id}: {e}"
         )
-        result = cursor.fetchone()
-    return json.loads(result[0] if result else "[]")
+        return []
 
 
 # Get the data for a given plugin
@@ -189,26 +244,53 @@ def get_plugin_data(plugin_name):
 
 # Get the longname for a given Meshtastic ID
 def get_longname(meshtastic_id):
-    with sqlite3.connect(get_db_path()) as conn:
-        cursor = conn.cursor()
-        cursor.execute(
-            "SELECT longname FROM longnames WHERE meshtastic_id=?", (meshtastic_id,)
-        )
-        result = cursor.fetchone()
-    return result[0] if result else None
+    """
+    Retrieve the long name associated with a given Meshtastic ID.
+
+    Parameters:
+        meshtastic_id (str): The Meshtastic node identifier.
+
+    Returns:
+        str or None: The long name if found, otherwise None.
+    """
+    try:
+        with sqlite3.connect(get_db_path()) as conn:
+            cursor = conn.cursor()
+            cursor.execute(
+                "SELECT longname FROM longnames WHERE meshtastic_id=?", (meshtastic_id,)
+            )
+            result = cursor.fetchone()
+        return result[0] if result else None
+    except sqlite3.Error as e:
+        logger.error(f"Database error retrieving longname for {meshtastic_id}: {e}")
+        return None
 
 
 def save_longname(meshtastic_id, longname):
-    with sqlite3.connect(get_db_path()) as conn:
-        cursor = conn.cursor()
-        cursor.execute(
-            "INSERT OR REPLACE INTO longnames (meshtastic_id, longname) VALUES (?, ?)",
-            (meshtastic_id, longname),
-        )
-        conn.commit()
+    """
+    Insert or update the long name for a given Meshtastic ID in the database.
+
+    If an entry for the Meshtastic ID already exists, its long name is updated; otherwise, a new entry is created.
+    """
+    try:
+        with sqlite3.connect(get_db_path()) as conn:
+            cursor = conn.cursor()
+            cursor.execute(
+                "INSERT OR REPLACE INTO longnames (meshtastic_id, longname) VALUES (?, ?)",
+                (meshtastic_id, longname),
+            )
+            conn.commit()
+    except sqlite3.Error as e:
+        logger.error(f"Database error saving longname for {meshtastic_id}: {e}")
 
 
 def update_longnames(nodes):
+    """
+    Updates the long names for all users in the provided nodes dictionary.
+
+    Parameters:
+        nodes (dict): A dictionary of nodes, each containing user information with Meshtastic IDs and long names.
+    """
     if nodes:
         for node in nodes.values():
             user = node.get("user")
@@ -219,26 +301,54 @@ def update_longnames(nodes):
 
 
 def get_shortname(meshtastic_id):
-    with sqlite3.connect(get_db_path()) as conn:
-        cursor = conn.cursor()
-        cursor.execute(
-            "SELECT shortname FROM shortnames WHERE meshtastic_id=?", (meshtastic_id,)
-        )
-        result = cursor.fetchone()
-    return result[0] if result else None
+    """
+    Retrieve the short name associated with a given Meshtastic ID.
+
+    Parameters:
+        meshtastic_id (str): The Meshtastic node ID to look up.
+
+    Returns:
+        str or None: The short name if found, or None if not found or on database error.
+    """
+    try:
+        with sqlite3.connect(get_db_path()) as conn:
+            cursor = conn.cursor()
+            cursor.execute(
+                "SELECT shortname FROM shortnames WHERE meshtastic_id=?",
+                (meshtastic_id,),
+            )
+            result = cursor.fetchone()
+        return result[0] if result else None
+    except sqlite3.Error as e:
+        logger.error(f"Database error retrieving shortname for {meshtastic_id}: {e}")
+        return None
 
 
 def save_shortname(meshtastic_id, shortname):
-    with sqlite3.connect(get_db_path()) as conn:
-        cursor = conn.cursor()
-        cursor.execute(
-            "INSERT OR REPLACE INTO shortnames (meshtastic_id, shortname) VALUES (?, ?)",
-            (meshtastic_id, shortname),
-        )
-        conn.commit()
+    """
+    Insert or update the short name for a given Meshtastic ID in the database.
+
+    If an entry for the Meshtastic ID already exists, its short name is updated; otherwise, a new entry is created.
+    """
+    try:
+        with sqlite3.connect(get_db_path()) as conn:
+            cursor = conn.cursor()
+            cursor.execute(
+                "INSERT OR REPLACE INTO shortnames (meshtastic_id, shortname) VALUES (?, ?)",
+                (meshtastic_id, shortname),
+            )
+            conn.commit()
+    except sqlite3.Error as e:
+        logger.error(f"Database error saving shortname for {meshtastic_id}: {e}")
 
 
 def update_shortnames(nodes):
+    """
+    Updates the short names for all users in the provided nodes dictionary.
+
+    Parameters:
+        nodes (dict): A dictionary of nodes, each containing user information with Meshtastic IDs and short names.
+    """
     if nodes:
         for node in nodes.values():
             user = node.get("user")
@@ -256,64 +366,103 @@ def store_message_map(
     meshtastic_meshnet=None,
 ):
     """
-    Stores a message map in the database.
-
-    :param meshtastic_id: The Meshtastic message ID (integer or None)
-    :param matrix_event_id: The Matrix event ID (string, primary key)
-    :param matrix_room_id: The Matrix room ID (string)
-    :param meshtastic_text: The text of the Meshtastic message
-    :param meshtastic_meshnet: The name of the meshnet this message originated from.
-                               This helps us identify remote vs local mesh origins.
+    Stores or updates a mapping between a Meshtastic message and its corresponding Matrix event in the database.
+
+    Parameters:
+        meshtastic_id: The Meshtastic message ID.
+        matrix_event_id: The Matrix event ID (primary key).
+        matrix_room_id: The Matrix room ID.
+        meshtastic_text: The text content of the Meshtastic message.
+        meshtastic_meshnet: Optional name of the meshnet where the message originated, used to distinguish remote from local mesh origins.
     """
-    with sqlite3.connect(get_db_path()) as conn:
-        cursor = conn.cursor()
-        logger.debug(
-            f"Storing message map: meshtastic_id={meshtastic_id}, matrix_event_id={matrix_event_id}, matrix_room_id={matrix_room_id}, meshtastic_text={meshtastic_text}, meshtastic_meshnet={meshtastic_meshnet}"
-        )
-        cursor.execute(
-            "INSERT OR REPLACE INTO message_map (meshtastic_id, matrix_event_id, matrix_room_id, meshtastic_text, meshtastic_meshnet) VALUES (?, ?, ?, ?, ?)",
-            (
-                meshtastic_id,
-                matrix_event_id,
-                matrix_room_id,
-                meshtastic_text,
-                meshtastic_meshnet,
-            ),
-        )
-        conn.commit()
+    try:
+        with sqlite3.connect(get_db_path()) as conn:
+            cursor = conn.cursor()
+            logger.debug(
+                f"Storing message map: meshtastic_id={meshtastic_id}, matrix_event_id={matrix_event_id}, matrix_room_id={matrix_room_id}, meshtastic_text={meshtastic_text}, meshtastic_meshnet={meshtastic_meshnet}"
+            )
+            cursor.execute(
+                "INSERT OR REPLACE INTO message_map (meshtastic_id, matrix_event_id, matrix_room_id, meshtastic_text, meshtastic_meshnet) VALUES (?, ?, ?, ?, ?)",
+                (
+                    meshtastic_id,
+                    matrix_event_id,
+                    matrix_room_id,
+                    meshtastic_text,
+                    meshtastic_meshnet,
+                ),
+            )
+            conn.commit()
+    except sqlite3.Error as e:
+        logger.error(f"Database error storing message map for {matrix_event_id}: {e}")
 
 
 def get_message_map_by_meshtastic_id(meshtastic_id):
-    with sqlite3.connect(get_db_path()) as conn:
-        cursor = conn.cursor()
-        cursor.execute(
-            "SELECT matrix_event_id, matrix_room_id, meshtastic_text, meshtastic_meshnet FROM message_map WHERE meshtastic_id=?",
-            (meshtastic_id,),
-        )
-        result = cursor.fetchone()
-        logger.debug(
-            f"Retrieved message map by meshtastic_id={meshtastic_id}: {result}"
+    """
+    Retrieve the message mapping entry for a given Meshtastic ID.
+
+    Returns:
+        tuple or None: A tuple (matrix_event_id, matrix_room_id, meshtastic_text, meshtastic_meshnet) if found and valid, or None if not found, on malformed data, or if a database error occurs.
+    """
+    try:
+        with sqlite3.connect(get_db_path()) as conn:
+            cursor = conn.cursor()
+            cursor.execute(
+                "SELECT matrix_event_id, matrix_room_id, meshtastic_text, meshtastic_meshnet FROM message_map WHERE meshtastic_id=?",
+                (meshtastic_id,),
+            )
+            result = cursor.fetchone()
+            logger.debug(
+                f"Retrieved message map by meshtastic_id={meshtastic_id}: {result}"
+            )
+            if result:
+                try:
+                    # result = (matrix_event_id, matrix_room_id, meshtastic_text, meshtastic_meshnet)
+                    return result[0], result[1], result[2], result[3]
+                except (IndexError, TypeError) as e:
+                    logger.error(
+                        f"Malformed data in message_map for meshtastic_id {meshtastic_id}: {e}"
+                    )
+                    return None
+            return None
+    except sqlite3.Error as e:
+        logger.error(
+            f"Database error retrieving message map for meshtastic_id {meshtastic_id}: {e}"
         )
-        if result:
-            # result = (matrix_event_id, matrix_room_id, meshtastic_text, meshtastic_meshnet)
-            return result[0], result[1], result[2], result[3]
         return None
 
 
 def get_message_map_by_matrix_event_id(matrix_event_id):
-    with sqlite3.connect(get_db_path()) as conn:
-        cursor = conn.cursor()
-        cursor.execute(
-            "SELECT meshtastic_id, matrix_room_id, meshtastic_text, meshtastic_meshnet FROM message_map WHERE matrix_event_id=?",
-            (matrix_event_id,),
-        )
-        result = cursor.fetchone()
-        logger.debug(
-            f"Retrieved message map by matrix_event_id={matrix_event_id}: {result}"
+    """
+    Retrieve the message mapping entry for a given Matrix event ID.
+
+    Returns:
+        tuple or None: A tuple (meshtastic_id, matrix_room_id, meshtastic_text, meshtastic_meshnet) if found, or None if not found or on error.
+    """
+    try:
+        with sqlite3.connect(get_db_path()) as conn:
+            cursor = conn.cursor()
+            cursor.execute(
+                "SELECT meshtastic_id, matrix_room_id, meshtastic_text, meshtastic_meshnet FROM message_map WHERE matrix_event_id=?",
+                (matrix_event_id,),
+            )
+            result = cursor.fetchone()
+            logger.debug(
+                f"Retrieved message map by matrix_event_id={matrix_event_id}: {result}"
+            )
+            if result:
+                try:
+                    # result = (meshtastic_id, matrix_room_id, meshtastic_text, meshtastic_meshnet)
+                    return result[0], result[1], result[2], result[3]
+                except (IndexError, TypeError) as e:
+                    logger.error(
+                        f"Malformed data in message_map for matrix_event_id {matrix_event_id}: {e}"
+                    )
+                    return None
+            return None
+    except (UnicodeDecodeError, sqlite3.Error) as e:
+        logger.error(
+            f"Database error retrieving message map for matrix_event_id {matrix_event_id}: {e}"
         )
-        if result:
-            # result = (meshtastic_id, matrix_room_id, meshtastic_text, meshtastic_meshnet)
-            return result[0], result[1], result[2], result[3]
         return None
 
 

mmrelay/log_utils.py

@@ -1,12 +1,17 @@
 import logging
-import os
 from logging.handlers import RotatingFileHandler
 
 from rich.console import Console
 from rich.logging import RichHandler
 
-from mmrelay.cli import parse_arguments
+# Import parse_arguments only when needed to avoid conflicts with pytest
 from mmrelay.config import get_log_dir
+from mmrelay.constants.app import APP_DISPLAY_NAME
+from mmrelay.constants.messages import (
+    DEFAULT_LOG_BACKUP_COUNT,
+    DEFAULT_LOG_SIZE_MB,
+    LOG_SIZE_BYTES_MULTIPLIER,
+)
 
 # Initialize Rich console
 console = Console()
@@ -68,12 +73,12 @@ def configure_component_debug_logging():
 
 def get_logger(name):
     """
-    Create and configure a logger with console and optional rotating file output, using global configuration and command-line arguments.
+    Create and configure a logger with console output (optionally colorized) and optional rotating file logging.
 
-    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".
+    The logger's log level, colorization, and file logging behavior are determined by global configuration and command-line arguments. Log files are rotated by size, and the log directory is created if necessary. If the logger name matches the application display name, the log file path is stored globally for reference.
 
     Parameters:
-        name (str): The name of the logger to create and configure.
+        name (str): The name of the logger to create.
 
     Returns:
         logging.Logger: The configured logger instance.
@@ -88,7 +93,11 @@ def get_logger(name):
     global config
     if config is not None and "logging" in config:
         if "level" in config["logging"]:
-            log_level = getattr(logging, config["logging"]["level"].upper())
+            try:
+                log_level = getattr(logging, config["logging"]["level"].upper())
+            except AttributeError:
+                # Invalid log level, fall back to default
+                log_level = logging.INFO
         # Check if colors should be disabled
         if "color_enabled" in config["logging"]:
             color_enabled = config["logging"]["color_enabled"]
@@ -96,6 +105,10 @@ def get_logger(name):
     logger.setLevel(log_level)
     logger.propagate = False
 
+    # Check if logger already has handlers to avoid duplicates
+    if logger.handlers:
+        return logger
+
     # Add handler for console logging (with or without colors)
     if color_enabled:
         # Use Rich handler with colors
@@ -121,17 +134,28 @@ def get_logger(name):
         )
     logger.addHandler(console_handler)
 
-    # Check command line arguments for log file path
-    args = parse_arguments()
+    # Check command line arguments for log file path (only if not in test environment)
+    args = None
+    try:
+        # Only parse arguments if we're not in a test environment
+        import os
+
+        if not os.environ.get("MMRELAY_TESTING"):
+            from mmrelay.cli import parse_arguments
+
+            args = parse_arguments()
+    except (SystemExit, ImportError):
+        # If argument parsing fails (e.g., in tests), continue without CLI arguments
+        pass
 
     # Check if file logging is enabled (default to True for better user experience)
     if (
         config is not None
         and config.get("logging", {}).get("log_to_file", True)
-        or args.logfile
+        or (args and args.logfile)
     ):
-        # Priority: 1. Command line arg, 2. Config file, 3. Default location (~/.mmrelay/logs)
-        if args.logfile:
+        # Priority: 1. Command line argument, 2. Config file, 3. Default location (~/.mmrelay/logs)
+        if args and args.logfile:
             log_file = args.logfile
         else:
             config_log_file = (
@@ -153,15 +177,15 @@ def get_logger(name):
             os.makedirs(log_dir, exist_ok=True)
 
         # Store the log file path for later use
-        if name == "M<>M Relay":
+        if name == APP_DISPLAY_NAME:
             global log_file_path
             log_file_path = log_file
 
         # Create a file handler for logging
         try:
             # Set up size-based log rotation
-            max_bytes = 10 * 1024 * 1024  # Default 10 MB
-            backup_count = 1  # Default to 1 backup
+            max_bytes = DEFAULT_LOG_SIZE_MB * LOG_SIZE_BYTES_MULTIPLIER
+            backup_count = DEFAULT_LOG_BACKUP_COUNT
 
             if config is not None and "logging" in config:
                 max_bytes = config["logging"].get("max_log_size", max_bytes)

mmrelay/main.py

@@ -15,6 +15,7 @@ from nio.events.room_events import RoomMemberEvent
 # Import version from package
 # Import meshtastic_utils as a module to set event_loop
 from mmrelay import __version__, meshtastic_utils
+from mmrelay.constants.app import APP_DISPLAY_NAME, WINDOWS_PLATFORM
 from mmrelay.db_utils import (
     initialize_database,
     update_longnames,
@@ -36,7 +37,7 @@ from mmrelay.message_queue import (
 from mmrelay.plugin_loader import load_plugins
 
 # Initialize logger
-logger = get_logger(name="M<>M Relay")
+logger = get_logger(name=APP_DISPLAY_NAME)
 
 # Set the logging level for 'nio' to ERROR to suppress warnings
 logging.getLogger("nio").setLevel(logging.ERROR)
@@ -57,9 +58,9 @@ def print_banner():
 
 async def main(config):
     """
-    Runs the main asynchronous relay loop, managing the lifecycle and coordination between Meshtastic and Matrix clients.
+    Coordinates the main asynchronous relay loop between Meshtastic and Matrix clients.
 
-    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.
+    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. Optionally wipes the message map on startup and shutdown if configured.
     """
     # Extract Matrix configuration
     from typing import List
@@ -133,7 +134,7 @@ async def main(config):
     loop = asyncio.get_running_loop()
 
     # Handle signals differently based on the platform
-    if sys.platform != "win32":
+    if sys.platform != WINDOWS_PLATFORM:
         for sig in (signal.SIGINT, signal.SIGTERM):
             loop.add_signal_handler(sig, lambda: asyncio.create_task(shutdown()))
     else: