Add config_entry title to all log messages.

This makes it easier to identify which heat pump the log message relates to.

Author: niobos

custom_components/mitsubishi/__init__.py

@@ -121,7 +121,9 @@ async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
         return True
 
     except Exception as ex:
-        _LOGGER.exception("Failed to set up Mitsubishi Air Conditioner: %s", ex)
+        _LOGGER.exception("[%s] Failed to set up Mitsubishi Air Conditioner: %s",
+                          entry.title,
+                          ex)
         raise ConfigEntryNotReady from ex
 
 
@@ -139,14 +141,16 @@ async def async_unload_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
         # This prevents the AC from being stuck with stale remote temperature data
         if coordinator.remote_temp_mode:
             try:
-                _LOGGER.info("Switching AC to internal temperature sensor during unload")
+                _LOGGER.info("[%s] Switching AC to internal temperature sensor during unload",
+                             entry.title)
                 await hass.async_add_executor_job(
                     coordinator.controller.set_current_temperature, None
                 )
             except Exception:
                 _LOGGER.warning(
-                    "Failed to switch AC to internal sensor during unload, "
-                    "AC may continue using last remote temperature"
+                    "[%s] Failed to switch AC to internal sensor during unload, "
+                    "AC may continue using last remote temperature",
+                    entry.title,
                 )
 
         # Close API connection
@@ -158,7 +162,8 @@ async def async_unload_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
 async def async_migrate_entry(hass: HomeAssistant, config_entry: ConfigEntry):
     """Migrate old entry."""
     _LOGGER.debug(
-        "Migrating configuration from version %s.%s",
+        "[%s] Migrating configuration from version %s.%s",
+        config_entry.title,
         config_entry.version,
     )
 

custom_components/mitsubishi/coordinator.py

@@ -48,7 +48,8 @@ def __init__(
 
         # Log the loaded state for debugging persistence issues
         _LOGGER.info(
-            "Coordinator initialized: remote_temp_mode=%s (from options: %s)",
+            "Coordinator for `%s` initialized: remote_temp_mode=%s (from options: %s)",
+            self.config_entry.title,
             self._remote_temp_mode,
             dict(config_entry.options),
         )
@@ -59,7 +60,7 @@ async def set_remote_temp_mode(self, enabled: bool) -> None:
         When disabling remote mode, this also tells the AC to use its internal sensor.
         """
         self._remote_temp_mode = enabled
-        _LOGGER.info("Remote temperature mode set to: %s", enabled)
+        _LOGGER.info("[%s] Remote temperature mode set to: %s", self.config_entry.title, enabled)
 
         # When disabling remote mode, tell the AC to use internal sensor
         if not enabled:
@@ -93,18 +94,19 @@ async def get_unit_info(self) -> dict:
 
     async def _async_update_data(self) -> ParsedDeviceState:
         """Update data via library."""
-        _LOGGER.debug("Coordinator fetching device status")
+        _LOGGER.debug("[%s] Coordinator fetching device status", self.config_entry.title)
 
         # Only process remote temperature if experimental features are enabled
         if self.experimental_features_enabled:
             # On first update after startup, restore the persisted mode to the AC
             if not self._startup_mode_applied:
                 self._startup_mode_applied = True
                 if self._remote_temp_mode:
-                    _LOGGER.info("Restoring remote temperature mode from persisted state")
+                    _LOGGER.info("[%s] Restoring remote temperature mode from persisted state",
+                                 self.config_entry.title)
                     await self._send_remote_temperature()
                 else:
-                    _LOGGER.debug("Starting with internal temperature mode")
+                    _LOGGER.debug("[%s] Starting with internal temperature mode", self.config_entry.title)
             elif self._remote_temp_mode:
                 # Regular update - send remote temperature if enabled
                 await self._send_remote_temperature()
@@ -131,8 +133,9 @@ async def _send_remote_temperature(self) -> None:
 
         if not external_entity_id:
             _LOGGER.warning(
-                "Remote temperature mode enabled but no external entity configured, "
-                "falling back to internal sensor"
+                "[%s] Remote temperature mode enabled but no external entity configured, "
+                "falling back to internal sensor",
+                self.config_entry.title,
             )
             await self.set_remote_temp_mode(False)
             return
@@ -141,8 +144,9 @@ async def _send_remote_temperature(self) -> None:
 
         if state is None:
             _LOGGER.warning(
-                "External temperature entity %s not found, "
+                "[%s External temperature entity %s not found, "
                 "temporarily using internal sensor (will retry)",
+                self.config_entry.title,
                 external_entity_id,
             )
             # Tell AC to use internal sensor temporarily, but don't disable remote mode
@@ -152,8 +156,9 @@ async def _send_remote_temperature(self) -> None:
 
         if state.state in (STATE_UNAVAILABLE, STATE_UNKNOWN):
             _LOGGER.warning(
-                "External temperature entity %s is %s, "
+                "[%s] External temperature entity %s is %s, "
                 "temporarily using internal sensor (will retry)",
+                self.config_entry.title,
                 external_entity_id,
                 state.state,
             )
@@ -165,7 +170,8 @@ async def _send_remote_temperature(self) -> None:
         try:
             temperature = float(state.state)
             _LOGGER.debug(
-                "Sending remote temperature %.1f from %s to AC",
+                "[%s] Sending remote temperature %.1f from %s to AC",
+                self.config_entry.title,
                 temperature,
                 external_entity_id,
             )
@@ -174,8 +180,9 @@ async def _send_remote_temperature(self) -> None:
             )
         except (ValueError, TypeError) as e:
             _LOGGER.error(
-                "Invalid temperature value '%s' from %s: %s, "
+                "[%s] Invalid temperature value '%s' from %s: %s, "
                 "temporarily using internal sensor (will retry)",
+                self.config_entry.title,
                 state.state,
                 external_entity_id,
                 e,

custom_components/mitsubishi/entity.py

@@ -78,31 +78,31 @@ async def _execute_command_with_refresh(
             bool: True if command was successful, False otherwise
         """
         try:
-            _LOGGER.debug(f"Executing command: {command_name}")
+            _LOGGER.debug(f"[{self._config_entry.title}] Executing command: {command_name}")
 
             # Execute the command
             success = await self.hass.async_add_executor_job(lambda: command_func(*args, **kwargs))
 
             if success:
-                _LOGGER.debug(f"Command '{command_name}' sent successfully")
+                _LOGGER.debug(f"[{self._config_entry.title}] Command '{command_name}' sent successfully")
 
                 # Based on timing tests, the device needs ~1.5-2 seconds to process
                 # commands and reflect changes in its status. The command response
                 # contains the OLD state, not the new state.
 
                 # Wait for the device to process the command
-                _LOGGER.debug(f"Waiting for device to process {command_name}...")
+                _LOGGER.debug(f"[{self._config_entry.title}] Waiting for device to process {command_name}...")
                 await asyncio.sleep(self.coordinator.controller.wait_time_after_command)
 
                 # Now fetch fresh data from the device
                 await self.coordinator.async_request_refresh()
-                _LOGGER.debug(f"Coordinator refreshed after {command_name}")
+                _LOGGER.debug(f"[{self._config_entry.title}] Coordinator refreshed after {command_name}")
 
                 return True
             else:
-                _LOGGER.warning(f"Failed to execute {command_name}")
+                _LOGGER.warning(f"[{self._config_entry.title}] Failed to execute {command_name}")
                 return False
 
         except Exception as e:
-            _LOGGER.error(f"Error executing {command_name}: {e}")
+            _LOGGER.error(f"[{self._config_entry.title}] Error executing {command_name}: {e}")
             return False

custom_components/mitsubishi/sensor.py

@@ -30,7 +30,8 @@ async def async_setup_entry(
     """Set up Mitsubishi sensors."""
     coordinator = hass.data[DOMAIN][config_entry.entry_id]
     _LOGGER.debug(
-        "Setting up Mitsubishi sensors with coordinator data available: %s",
+        "[%s] Setting up Mitsubishi sensors with coordinator data available: %s",
+        config_entry.title,
         coordinator.data is not None,
     )