fix: make filter dedup survive module reloads, not just repeat calls

CodeRabbit follow-up: _add_filter_once's isinstance() check only dedups
filters within a single loaded generation of ha_mcp.log_filters. The
in-process embedded server purges ha_mcp.* from sys.modules and re-imports
fresh on every reinstall (_purge_ha_mcp_modules), so filter_cls is a BRAND
NEW class object each reload -- isinstance() against a stale-generation
instance never matches, so filters accumulated one more stale instance per
reload indefinitely (the actual real-world case for this server, not the
same-generation repeat-call case the previous fix covered).

Match by (module, qualname) instead, which is stable across reloads of the
same module path, and actively replace any stale-generation match rather
than just skipping when one is found -- a logger always carries exactly
one, current-generation filter of each type.

Regression test simulates a stale-generation instance directly (a
dynamically-built class sharing the real one's module/qualname) rather than
via importlib.reload(): reloading the real module mutates shared global
state and was observed to break unrelated sibling test files that import
these classes at their own module scope -- caught by running the full
affected test set with --maxfail=0 before this commit.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>

Author: swissmo

src/ha_mcp/log_filters.py

@@ -150,17 +150,30 @@ def filter(self, record: logging.LogRecord) -> bool:
 
 
 def _add_filter_once(logger_name: str, filter_cls: type[logging.Filter]) -> None:
-    """Attach one ``filter_cls`` instance to ``logger_name``, unless already present.
+    """Attach one ``filter_cls`` instance to ``logger_name``, replacing any stale one.
 
     ``install_sdk_log_filters()`` can run more than once per process: the
     in-process embedded server calls it on every ``_serve()`` reload without
     a process restart, and process-wide ``logging`` state (including each
-    named logger's filter list) persists across those reloads. Without this
-    guard, filters would accumulate one more redundant instance per reload.
+    named logger's filter list) persists across those reloads. Each reload
+    also re-imports this module from scratch (the embedded server purges
+    ``ha_mcp.*`` from ``sys.modules`` before reinstalling -- see
+    ``_purge_ha_mcp_modules``), so ``filter_cls`` is a BRAND NEW class object
+    each time, even though its name is unchanged. A same-``isinstance``-check
+    against a filter instance from a PREVIOUS generation would therefore
+    never match, letting filters accumulate one more stale instance per
+    reload forever. Match by ``(module, qualname)`` instead -- stable across
+    reloads of the same module path -- and drop every stale-generation match
+    before attaching the current one, so a logger never carries more than
+    one filter of a given conceptual type, and it's always this generation's.
     """
     logger = logging.getLogger(logger_name)
-    if any(isinstance(f, filter_cls) for f in logger.filters):
-        return
+    identity = (filter_cls.__module__, filter_cls.__qualname__)
+    logger.filters[:] = [
+        f
+        for f in logger.filters
+        if (type(f).__module__, type(f).__qualname__) != identity
+    ]
     logger.addFilter(filter_cls())
 
 

tests/src/unit/test_log_filters_install.py

@@ -16,6 +16,23 @@
 }
 
 
+def _make_stale_generation_filter(real_cls: type[logging.Filter]) -> logging.Filter:
+    """Build an instance whose (module, qualname) matches ``real_cls`` but whose
+    class object is a genuinely DIFFERENT one -- simulating a filter instance
+    left over from a previous ``ha_mcp.log_filters`` generation after the
+    in-process embedded server purges and re-imports it (see
+    ``_purge_ha_mcp_modules``), without actually reloading any module.
+    ``importlib.reload()`` mutates the real, shared module in place, which
+    would corrupt every OTHER test file's already-imported reference to these
+    same class names for the rest of the pytest session -- this builds an
+    equivalent stand-in instead.
+    """
+    stale_cls = type(
+        real_cls.__qualname__, (logging.Filter,), {"__module__": real_cls.__module__}
+    )
+    return stale_cls()
+
+
 class TestInstallSdkLogFiltersIdempotent:
     """The in-process embedded server calls this on every reload without a
     process restart, so process-wide logger filter lists persist across
@@ -44,3 +61,48 @@ def test_second_call_does_not_duplicate_filters(self):
             assert len(matches) == 1, (
                 f"{name} must carry exactly one {filter_cls.__name__}, got {len(matches)}"
             )
+
+
+class TestInstallSdkLogFiltersReplacesStaleGeneration:
+    """The in-process embedded server purges ``ha_mcp.*`` from ``sys.modules``
+    and re-imports on every reinstall (see ``_purge_ha_mcp_modules``), so
+    ``ha_mcp.log_filters`` is a fresh module with fresh classes after each
+    reload -- a stale filter instance from before the reload (a DIFFERENT
+    class object with the same name) must be replaced, not left to
+    accumulate alongside the new one."""
+
+    def setup_method(self):
+        """Snapshot each logger's filters, then plant a stale-generation
+        stand-in filter on each -- the state a real reload would leave
+        behind, without actually reloading any module."""
+        self._saved = {
+            name: logging.getLogger(name).filters[:] for name in _TARGET_LOGGERS
+        }
+        for name, filter_cls in _TARGET_LOGGERS.items():
+            logging.getLogger(name).filters[:] = [
+                _make_stale_generation_filter(filter_cls)
+            ]
+
+    def teardown_method(self):
+        """Restore each target logger's filter list, undoing this test's calls."""
+        for name, filters in self._saved.items():
+            logging.getLogger(name).filters[:] = filters
+
+    def test_stale_generation_instance_is_replaced_not_duplicated(self):
+        """A planted stale-generation filter is replaced, never duplicated."""
+        stale = {name: logging.getLogger(name).filters[0] for name in _TARGET_LOGGERS}
+
+        install_sdk_log_filters()
+
+        for name, filter_cls in _TARGET_LOGGERS.items():
+            filters = logging.getLogger(name).filters
+            assert len(filters) == 1, (
+                f"{name} must carry exactly one filter after replacing the "
+                f"stale generation, got {len(filters)}"
+            )
+            assert filters[0] is not stale[name], (
+                f"{name}'s stale pre-reload filter instance must be replaced, not kept"
+            )
+            assert isinstance(filters[0], filter_cls), (
+                f"{name}'s replacement filter must be the current, real {filter_cls.__name__}"
+            )