fix(core): apply level + propagate every call; tolerate pre-attached handlers

src/core/logger.py

@@ -16,8 +16,14 @@ _DATE_FORMAT = "%Y-%m-%dT%H:%M:%S"
 def get_logger(name: str, level: int = logging.INFO) -> logging.Logger:
     """Return a process-wide singleton logger for the given name.
 
-    Idempotent: repeated calls with the same name return the same Logger
-    instance and never stack duplicate handlers.
+    Idempotent on handler attachment: repeated calls with the same name
+    return the same Logger instance and never stack duplicate stdout
+    StreamHandlers. The most recent call wins on `level`, so callers can
+    raise/lower verbosity at runtime without rebuilding the logger.
+
+    Note on `propagate=False`: records do NOT bubble up to the root logger.
+    If a framework (FastAPI, Uvicorn, MLflow) needs to capture records via
+    a root handler in week-2 work, this default will need to be revisited.
 
     Args:
         name: Dotted logger name, conventionally `__name__`.
@@ -27,12 +33,13 @@ def get_logger(name: str, level: int = logging.INFO) -> logging.Logger:
         Configured `logging.Logger` writing to stdout.
     """
     logger = logging.getLogger(name)
-    if logger.handlers:
-        return logger
-
-    handler = logging.StreamHandler(stream=sys.stdout)
-    handler.setFormatter(logging.Formatter(_LOG_FORMAT, datefmt=_DATE_FORMAT))
-    logger.addHandler(handler)
     logger.setLevel(level)
     logger.propagate = False
+    if not any(
+        isinstance(h, logging.StreamHandler) and h.stream is sys.stdout
+        for h in logger.handlers
+    ):
+        handler = logging.StreamHandler(stream=sys.stdout)
+        handler.setFormatter(logging.Formatter(_LOG_FORMAT, datefmt=_DATE_FORMAT))
+        logger.addHandler(handler)
     return logger

tests/core/test_logger.py

@@ -62,3 +62,33 @@ def test_get_logger_format_includes_level_and_name() -> None:
     assert "INFO" in output
     assert "neurobridge.format_check" in output
     assert "payload" in output
+
+
+def test_get_logger_respects_subsequent_level_change() -> None:
+    """The most recent call wins on level — fixes a silent no-op regression."""
+    name = "neurobridge.level_change"
+    first = get_logger(name, level=logging.INFO)
+    assert first.level == logging.INFO
+    second = get_logger(name, level=logging.DEBUG)
+    assert second is first  # still the same singleton
+    assert second.level == logging.DEBUG
+
+
+def test_get_logger_does_not_clobber_pre_attached_handlers() -> None:
+    """If a framework pre-attached a handler, we still apply our config."""
+    name = "neurobridge.pre_attached"
+    pre_existing = logging.NullHandler()
+    logging.getLogger(name).addHandler(pre_existing)
+
+    logger = get_logger(name)
+
+    # Our stdout StreamHandler was added alongside the pre-existing handler.
+    assert pre_existing in logger.handlers
+    assert any(
+        isinstance(h, logging.StreamHandler) and getattr(h, "stream", None) is not None
+        and h is not pre_existing
+        for h in logger.handlers
+    )
+    # And our config (level + propagate) actually took effect.
+    assert logger.level == logging.INFO
+    assert logger.propagate is False