Fixes #6

Author: DSorlov

CHANGELOG.md

@@ -8,10 +8,15 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ## [1.1.0] - 2025-10-14
 
 ### Added
-- Cached values feature: Integration now remembers last known sensor values when printer is offline
+- Cached values feature: Integration now remembers last known sensor values when printer is offline (Issue #3)
 - Offline status indication in sensor attributes with timestamp of last successful data fetch
 - Status sensor now shows "offline" state when using cached data
 
+### Fixed
+- Reduced excessive SNMP error logging when printer is offline (Issue #6)
+- SNMP errors now log once as ERROR, then at WARNING level every 5 minutes to prevent log spam
+- Connection recovery is properly logged when printer comes back online
+
 ## [1.0.0] - 2025-10-01
 
 ### Added

custom_components/snmp_printer/__init__.py

@@ -84,7 +84,7 @@ async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
 
     # Create storage for cached data
     store = Store(hass, STORAGE_VERSION, f"{STORAGE_KEY}_{entry.entry_id}")
-    
+
     # Load cached data
     cached_data = await store.async_load() or {}
 
@@ -109,38 +109,52 @@ async def async_update_data():
                     entry.data[CONF_HOST], hass
                 ),
             }
-            
+
             # Save successful data to cache with timestamp
             cache_data = {
                 "data": data,
                 "timestamp": datetime.now().isoformat(),
-                "host": entry.data[CONF_HOST]
+                "host": entry.data[CONF_HOST],
             }
             await store.async_save(cache_data)
-            
+
             # Mark as online
             data["is_online"] = True
-            
+
             return data
         except Exception as err:
             # Check if this is a connection-related error
             error_msg = str(err).lower()
-            is_connection_error = any(keyword in error_msg for keyword in [
-                "timeout", "unreachable", "no route", "connection", "network", 
-                "host", "refused", "failed", "no response"
-            ])
-            
+            is_connection_error = any(
+                keyword in error_msg
+                for keyword in [
+                    "timeout",
+                    "unreachable",
+                    "no route",
+                    "connection",
+                    "network",
+                    "host",
+                    "refused",
+                    "failed",
+                    "no response",
+                ]
+            )
+
             # If we have cached data and this is a connection issue, return cached data
             if cached_data.get("data") and is_connection_error:
-                _LOGGER.warning("Printer %s is offline (%s), using cached data from %s", 
-                               entry.data[CONF_HOST], err, cached_data.get("timestamp", "unknown"))
-                
+                _LOGGER.warning(
+                    "Printer %s is offline (%s), using cached data from %s",
+                    entry.data[CONF_HOST],
+                    err,
+                    cached_data.get("timestamp", "unknown"),
+                )
+
                 cached_printer_data = cached_data["data"].copy()
                 cached_printer_data["is_online"] = False
                 cached_printer_data["offline_since"] = cached_data.get("timestamp")
-                
+
                 return cached_printer_data
-            
+
             # For other errors or when we don't have cached data, re-raise the error
             raise UpdateFailed(f"Error fetching printer data: {err}") from err
 

custom_components/snmp_printer/const.py

@@ -20,6 +20,11 @@
 DEFAULT_UPDATE_INTERVAL: Final = 60
 DEFAULT_SNMP_VERSION: Final = "2c"
 
+# Error logging configuration
+DEFAULT_ERROR_LOG_INTERVAL: Final = (
+    300  # Log offline errors at most once every 5 minutes
+)
+
 # SNMP OIDs based on RFC 3805 (Printer MIB) and RFC 1213 (MIB-II)
 # System information
 OID_SYSTEM_DESCRIPTION: Final = "1.3.6.1.2.1.1.1.0"

custom_components/snmp_printer/snmp_client.py

@@ -4,6 +4,7 @@
 
 import logging
 import re
+import time
 from typing import Any
 
 from pysnmp.hlapi.v3arch.asyncio import (
@@ -25,8 +26,11 @@
 from pysnmp.proto.rfc1902 import OctetString
 
 from .const import (
+    DEFAULT_ERROR_LOG_INTERVAL,
     DEVICE_STATUS,
+    OID_COVER_DESCRIPTION,
     OID_COVER_STATUS,
+    OID_DEVICE_DESCRIPTION,
     OID_DEVICE_ERRORS,
     OID_DEVICE_STATE,
     OID_DISPLAY_BUFFER,
@@ -41,6 +45,8 @@
     OID_MARKER_SUPPLIES_TYPE,
     OID_MEMORY_SIZE,
     OID_PAGE_COUNT,
+    OID_PRINTER_ERRORS,
+    OID_PRINTER_STATUS,
     OID_SERIAL_NUMBER,
     OID_SYSTEM_CONTACT,
     OID_SYSTEM_DESCRIPTION,
@@ -93,12 +99,73 @@ def __init__(
         self._transport = None  # Will be created async
         self._auth_data = self._get_auth_data()
 
+        # Connection state tracking for better error logging
+        self._connection_state = "unknown"  # unknown, online, offline
+        self._last_error_log_time = 0
+        self._consecutive_failures = 0
+
     def _create_engine(self):
         """Create SNMP engine (blocking operation)."""
         if self._engine is None:
             self._engine = SnmpEngine()
         return self._engine
 
+    def _handle_snmp_error(self, error_message: str) -> None:
+        """Handle SNMP errors with intelligent logging to reduce spam."""
+        current_time = time.time()
+        self._consecutive_failures += 1
+
+        # Determine if we should log this error
+        should_log_error = False
+        log_level = logging.ERROR
+
+        if self._connection_state == "unknown" or self._connection_state == "online":
+            # First error or was previously online - log as error
+            should_log_error = True
+            self._connection_state = "offline"
+            self._last_error_log_time = current_time
+        elif self._connection_state == "offline":
+            # Already offline - check if enough time has passed for another log
+            time_since_last_log = current_time - self._last_error_log_time
+            if time_since_last_log >= DEFAULT_ERROR_LOG_INTERVAL:
+                should_log_error = True
+                log_level = logging.WARNING  # Reduce severity for ongoing issues
+                self._last_error_log_time = current_time
+
+        if should_log_error:
+            if self._consecutive_failures == 1:
+                _LOGGER.error(
+                    "Printer %s: %s (switching to cached data if available)",
+                    self.host,
+                    error_message,
+                )
+            else:
+                _LOGGER.warning(
+                    "Printer %s still offline: %s (attempt %d, using cached data)",
+                    self.host,
+                    error_message,
+                    self._consecutive_failures,
+                )
+        else:
+            # Still log at debug level for troubleshooting
+            _LOGGER.debug(
+                "Printer %s offline: %s (suppressed, attempt %d)",
+                self.host,
+                error_message,
+                self._consecutive_failures,
+            )
+
+    def _mark_connection_success(self) -> None:
+        """Mark a successful connection to reset error tracking."""
+        if self._connection_state == "offline":
+            _LOGGER.info(
+                "Printer %s is back online after %d failed attempts",
+                self.host,
+                self._consecutive_failures,
+            )
+        self._connection_state = "online"
+        self._consecutive_failures = 0
+
     async def _ensure_transport(self):
         """Ensure transport and engine are created (async operation)."""
         if self._engine is None:
@@ -160,17 +227,16 @@ async def _get_oid(self, oid: str) -> Any:
         )
 
         if errorIndication:
-            _LOGGER.debug("SNMP error: %s", errorIndication)
+            self._handle_snmp_error(f"SNMP error: {errorIndication}")
             return None
         elif errorStatus:
-            _LOGGER.debug(
-                "SNMP error: %s at %s",
-                errorStatus.prettyPrint(),
-                errorIndex and varBinds[int(errorIndex) - 1][0] or "?",
+            self._handle_snmp_error(
+                f"SNMP error: {errorStatus.prettyPrint()} at {errorIndex and varBinds[int(errorIndex) - 1][0] or '?'}"
             )
             return None
 
         for varBind in varBinds:
+            self._mark_connection_success()
             return varBind[1].prettyPrint()
 
         return None
@@ -191,16 +257,18 @@ async def _walk_oid(self, oid: str) -> dict[str, str]:
             lexicographicMode=False,
         ):
             if errorIndication:
-                _LOGGER.error("SNMP walk error: %s", errorIndication)
+                self._handle_snmp_error(f"SNMP walk error: {errorIndication}")
                 break
             elif errorStatus:
-                _LOGGER.error(
-                    "SNMP walk error: %s at %s",
-                    errorStatus.prettyPrint(),
-                    errorIndex and varBinds[int(errorIndex) - 1][0] or "?",
+                self._handle_snmp_error(
+                    f"SNMP walk error: {errorStatus.prettyPrint()} at {errorIndex and varBinds[int(errorIndex) - 1][0] or '?'}"
                 )
                 break
             else:
+                # Mark success if we get any data
+                if not results and varBinds:
+                    self._mark_connection_success()
+
                 for varBind in varBinds:
                     # Extract the index from the OID (last part after the base OID)
                     full_oid = str(varBind[0])