Improve logging and add repairs and diagnostics

Author: chicco-carone

custom_components/power_load_balancer/__init__.py

@@ -203,7 +203,7 @@ async def _handle_turn_off_appliance_service(call: ServiceCall) -> None:
         entity_id = call.data[ATTR_ENTITY_ID]
         reason = call.data.get(ATTR_REASON, "")
 
-        logger.info(
+        logger.debug(
             "Turn off appliance service called",
             entity_id=entity_id,
             reason=reason,
@@ -234,7 +234,7 @@ async def _handle_turn_on_appliance_service(call: ServiceCall) -> None:
         entity_id = call.data[ATTR_ENTITY_ID]
         reason = call.data.get(ATTR_REASON, "")
 
-        logger.info(
+        logger.debug(
             "Turn on appliance service called",
             entity_id=entity_id,
             reason=reason,

custom_components/power_load_balancer/appliance_controller.py

@@ -465,7 +465,7 @@ async def auto_turn_on_task(
                     )
                     await asyncio.sleep(delay_seconds)
 
-                    logger.info(
+                    logger.debug(
                         "Auto turn-on timer expired", entity_id=entity_to_restore
                     )
 
@@ -493,7 +493,7 @@ async def auto_turn_on_task(
                     )
 
                     if available_budget < expected_power_value:
-                        logger.warning(
+                        logger.debug(
                             "Cannot auto turn-on: Insufficient power headroom",
                             entity_id=entity_to_restore,
                             available_budget=available_budget,
@@ -560,7 +560,7 @@ async def turn_off_appliance(self, entity_id: str, reason: str = "") -> None:
             appliance_state = validate_entity_state(self.hass, entity_id)
 
             if not self._is_appliance_active(entity_id, appliance_state.state):
-                logger.warning(
+                logger.debug(
                     "Appliance is not in an active state",
                     entity_id=entity_id,
                     current_state=appliance_state.state,
@@ -692,7 +692,7 @@ async def turn_off_appliance_service(
         )
 
         try:
-            logger.info(
+            logger.debug(
                 "Service turn_off_appliance called",
                 entity_id=entity_id,
                 reason=reason,
@@ -703,7 +703,7 @@ async def turn_off_appliance_service(
             appliance_state = validate_entity_state(self.hass, entity_id)
 
             if not self._is_appliance_active(entity_id, appliance_state.state):
-                logger.warning(
+                logger.debug(
                     "Appliance is not in an active state",
                     entity_id=entity_id,
                     current_state=appliance_state.state,
@@ -851,7 +851,7 @@ async def turn_on_appliance_service(
         )
 
         try:
-            logger.info(
+            logger.debug(
                 "Service turn_on_appliance called",
                 entity_id=entity_id,
                 reason=reason,
@@ -862,7 +862,7 @@ async def turn_on_appliance_service(
             appliance_state = validate_entity_state(self.hass, entity_id)
 
             if not self._is_appliance_off(entity_id, appliance_state.state):
-                logger.warning(
+                logger.debug(
                     "Appliance is not in 'off' state",
                     entity_id=entity_id,
                     current_state=appliance_state.state,
@@ -968,3 +968,20 @@ def cleanup(self) -> None:
         self._expected_power_restoration.clear()
         self._balanced_off_appliances.clear()
         self._previous_hvac_modes.clear()
+
+    def get_diagnostics_snapshot(self) -> dict[str, Any]:
+        """Return runtime diagnostics data for troubleshooting."""
+        scheduled_tasks = {
+            entity_id: {
+                "done": task.done(),
+                "cancelled": task.cancelled(),
+            }
+            for entity_id, task in self._scheduled_auto_turn_ons.items()
+        }
+
+        return {
+            "balanced_off_appliances": dict(self._balanced_off_appliances),
+            "expected_power_restoration_watt": dict(self._expected_power_restoration),
+            "scheduled_auto_turn_on_tasks": scheduled_tasks,
+            "stored_previous_hvac_modes": dict(self._previous_hvac_modes),
+        }

custom_components/power_load_balancer/balancing_engine.py

@@ -62,6 +62,7 @@ def __init__(
         self.hass = hass
         self._monitored_sensors = monitored_sensors
         self._power_budget = power_budget
+        self._reported_balance_down_failure = False
 
     def _is_climate_entity(self, entity_id: str) -> bool:
         """Check if an entity is a climate entity."""
@@ -207,15 +208,19 @@ def balance_down(
                     expected_power_reduction,
                 )
 
+                optimistic_reduction = 0.0
                 if expected_power_reduction > 0:
-                    reduce_estimated_power_callback(expected_power_reduction)
+                    optimistic_reduction = expected_power_reduction
+                    reduce_estimated_power_callback(optimistic_reduction)
                     _LOGGER.debug(
                         "Optimistically reduced estimated power by %s W for %s",
-                        expected_power_reduction,
+                        optimistic_reduction,
                         appliance_entity_id,
                     )
 
-                async def turn_off_task(inner_appliance_id: str) -> None:
+                async def turn_off_task(
+                    inner_appliance_id: str, reduced_power: float
+                ) -> None:
                     try:
                         appliance_state_before = self.hass.states.get(
                             inner_appliance_id
@@ -236,14 +241,31 @@ async def turn_off_task(inner_appliance_id: str) -> None:
                             f"{self._power_budget} W",
                         )
                     except Exception:
+                        if reduced_power > 0:
+                            reduce_estimated_power_callback(-reduced_power)
+                            _LOGGER.debug(
+                                "Restored estimated power by %s W for %s after "
+                                "turn-off failure",
+                                reduced_power,
+                                inner_appliance_id,
+                            )
                         _LOGGER.exception(
                             "Failed to turn off appliance %s", inner_appliance_id
                         )
 
-                self.hass.async_create_task(turn_off_task(appliance_entity_id))
+                self.hass.async_create_task(
+                    turn_off_task(appliance_entity_id, optimistic_reduction)
+                )
+                self._reported_balance_down_failure = False
                 return
 
-        _LOGGER.warning(
-            "Could not balance power below budget by turning off non-last-resort "
-            "appliances."
-        )
+        if self._reported_balance_down_failure:
+            _LOGGER.debug(
+                "Still unable to balance power using non-last-resort appliances"
+            )
+        else:
+            _LOGGER.warning(
+                "Could not balance power below budget by turning off non-last-resort "
+                "appliances."
+            )
+            self._reported_balance_down_failure = True

custom_components/power_load_balancer/diagnostics.py

@@ -0,0 +1,48 @@
+"""Diagnostics support for the Power Load Balancer integration."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from homeassistant.components.diagnostics import async_redact_data
+from homeassistant.const import CONF_ENTITY_ID
+
+from .const import CONF_APPLIANCE, CONF_MAIN_POWER_SENSOR, CONF_POWER_SENSORS, DOMAIN
+from .power_balancer import PowerLoadBalancer
+
+if TYPE_CHECKING:
+    from homeassistant.config_entries import ConfigEntry
+    from homeassistant.core import HomeAssistant
+
+TO_REDACT = {
+    CONF_APPLIANCE,
+    CONF_ENTITY_ID,
+    CONF_MAIN_POWER_SENSOR,
+    CONF_POWER_SENSORS,
+    "context_id",
+    "entry_id",
+    "main_power_sensor_entity_id",
+    "monitored_sensors",
+}
+
+
+async def async_get_config_entry_diagnostics(
+    hass: HomeAssistant, entry: ConfigEntry
+) -> dict[str, Any]:
+    """Return diagnostics for a config entry."""
+    domain_data = hass.data.get(DOMAIN, {})
+    power_balancer = domain_data.get(entry.entry_id)
+
+    runtime_data: dict[str, Any] = {"available": False}
+    if isinstance(power_balancer, PowerLoadBalancer):
+        runtime_data = {
+            "available": True,
+            "snapshot": power_balancer.get_diagnostics_snapshot(),
+        }
+
+    diagnostics_data: dict[str, Any] = {
+        "entry": entry.as_dict(),
+        "runtime": runtime_data,
+    }
+
+    return async_redact_data(diagnostics_data, TO_REDACT)