Add FlagAwareModel comments, log_level setting, align tests with simplified FeatureFlagManager

- Add block comment on FlagAwareModel explaining how LD flag lookup works
  (prefix propagation, .get() vs direct access, model_dump unaffected)
- Add log_level as top-level Settings field (default "INFO"), LD-overridable
  via flag key "log_level"
- Settings now extends FlagAwareModel so .get() works at the top level
- Update tests to match user's simplified FeatureFlagManager (raises on
  construction failure, no empty-string fallback)
- Add TestLogLevel covering default, config, env, and LD override

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: aniket-s-kulkarni

src/dremioai/config/feature_flags.py

@@ -13,7 +13,7 @@
 #  See the License for the specific language governing permissions and
 #  limitations under the License.
 #
-from typing import Optional, Any, Self
+from typing import Optional, Any, Self, ClassVar
 from dremioai import log
 import ldclient
 from ldclient.config import Config
@@ -22,66 +22,49 @@
 class FeatureFlagManager:
     """Manages LaunchDarkly feature flags for MCP server."""
 
-    _instance: Optional[Self] = None
-    _client: Optional[ldclient.LDClient] = None
+    _log = log.logger("feature_flags")
+    _instance: ClassVar[Self] = None
 
     def __init__(self, sdk_key: str):
-        if not sdk_key:
-            log.logger("feature_flags").warning(
-                "LaunchDarkly SDK key is empty, feature flags will be disabled"
-            )
-            return
-
         try:
             ldclient.set_config(Config(sdk_key))
             self._client = ldclient.get()
 
             if self._client.is_initialized():
-                log.logger("feature_flags").info(
-                    "LaunchDarkly client initialized successfully"
-                )
+                self._log.info("LaunchDarkly client initialized successfully")
             else:
-                log.logger("feature_flags").warning(
-                    "LaunchDarkly client initialization pending"
-                )
-        except Exception as e:
-            log.logger("feature_flags").error(
-                f"Failed to initialize LaunchDarkly client: {e}"
-            )
+                self._log.warning("LaunchDarkly client initialization pending")
+        except:
+            self._log.exception(f"Failed to initialize LaunchDarkly client")
+            raise
 
     @classmethod
     def instance(cls) -> Self:
         """Lazily initializes from settings.instance().dremio.launchdarkly.sdk_key."""
         if cls._instance is None:
-            from dremioai.config import settings as _settings
+            from dremioai.config import settings
 
-            sdk_key = None
-            s = _settings.instance()
-            if s and s.dremio and s.dremio.launchdarkly:
-                sdk_key = s.dremio.launchdarkly.sdk_key
-            cls._instance = cls(sdk_key or "")
+            sdk_key = settings.instance().dremio.launchdarkly.sdk_key
+            cls._instance = cls(sdk_key)
         return cls._instance
 
     @classmethod
     def reset(cls):
         if cls._instance and cls._instance._client:
             cls._instance._client.close()
         cls._instance = None
-        cls._client = None
 
     def is_enabled(self) -> bool:
         return self._client is not None and self._client.is_initialized()
 
     def get_flag(self, flag_key: str, default: Any) -> Any:
-        try:
-            if self.is_enabled():
-                value = self._client.variation(flag_key, ldclient.Context.create("mcp-server"), default)
-                log.logger("feature_flags").debug(
-                    f"Flag '{flag_key}' evaluated to: {value} (default: {default})"
-                )
-                return value
-        except Exception:
-            log.logger("feature_flags").exception(
-                f"Error evaluating flag '{flag_key}' using default: {default}"
+        if not self.is_enabled():
+            self._log.debug(
+                f"Flag '{flag_key}' not evaluated, LaunchDarkly not enabled/initialized (default: {default})"
             )
-        return default
+            return default
+        value = self._client.variation(
+            flag_key, ldclient.Context.create("mcp-server"), default
+        )
+        self._log.debug(f"Flag '{flag_key}' evaluated to: {value} (default: {default})")
+        return value

src/dremioai/config/settings.py

@@ -63,11 +63,24 @@ def get(self, field_name: str, default: Any = None):
         return getattr(self, field_name, default)
 
 
+# FlagAwareModel overrides .get() to check LaunchDarkly before returning the
+# config value. The LD flag key is "{_flag_prefix}.{field_name}", e.g.
+# "dremio.allow_dml" or "dremio.api.http_retry.max_retries".
+#
+# _flag_prefix is auto-set by _propagate_flag_prefixes() during
+# Settings.model_post_init — it mirrors the model's nesting path.
+#
+# Direct attribute access (obj.field) always returns the config value;
+# only .get() consults LD. This keeps model_dump() and serialization
+# unaffected by remote flag state.
 class FlagAwareModel(GetterModel):
     _flag_prefix: str = ""
 
     def get(self, field_name: str, default: Any = None):
-        mgr = FeatureFlagManager.instance()
+        try:
+            mgr = FeatureFlagManager.instance()
+        except Exception:
+            return super().get(field_name, default)
         if mgr.is_enabled():
             key = f"{self._flag_prefix}.{field_name}" if self._flag_prefix else field_name
             if (flag := mgr.get_flag(key, default=default)) is not None:
@@ -339,7 +352,8 @@ class BeeAI(FlagAwareModel):
     ollama: Optional[Ollama] = Field(default=None)
 
 
-class Settings(BaseSettings):
+class Settings(FlagAwareModel, BaseSettings):
+    log_level: Optional[str] = Field(default="INFO")
     dremio: Optional[Dremio] = Field(default=None)
     tools: Optional[Tools] = Field(default_factory=Tools)
     prometheus: Optional[Prometheus] = Field(default=None)
@@ -351,6 +365,7 @@ class Settings(BaseSettings):
         env_prefix="DREMIOAI_",
         env_extra="allow",
         use_enum_values=True,
+        validate_assignment=True,
     )
 
     def model_post_init(self, __context):

tests/config/test_launchdarkly_integration.py

@@ -56,12 +56,6 @@ def test_initialization_with_sdk_key(self, mock_ldclient):
         mock_ldclient.set_config.assert_called_once()
         assert mgr.is_enabled() is True
 
-    @patch("dremioai.config.feature_flags.ldclient")
-    def test_initialization_without_sdk_key(self, mock_ldclient):
-        mgr = FeatureFlagManager("")
-        assert mgr.is_enabled() is False
-        mock_ldclient.set_config.assert_not_called()
-
     @patch("dremioai.config.feature_flags.ldclient")
     def test_get_flag_returns_ld_value(self, mock_ldclient):
         mock_client = _make_mock_ld_client({"my_flag": True})
@@ -79,14 +73,13 @@ def test_get_flag_returns_default_when_not_found(self, mock_ldclient):
         assert mgr.get_flag("unknown_flag", default="fallback") == "fallback"
 
     @patch("dremioai.config.feature_flags.ldclient")
-    def test_get_flag_returns_default_on_exception(self, mock_ldclient):
+    def test_get_flag_returns_default_when_not_initialized(self, mock_ldclient):
         mock_client = MagicMock()
-        mock_client.is_initialized.return_value = True
-        mock_client.variation.side_effect = Exception("LD error")
+        mock_client.is_initialized.return_value = False
         mock_ldclient.get.return_value = mock_client
 
         mgr = FeatureFlagManager("test-sdk-key")
-        assert mgr.get_flag("error_flag", default="safe_default") == "safe_default"
+        assert mgr.get_flag("any_flag", default="fallback") == "fallback"
 
     @patch("dremioai.config.feature_flags.ldclient")
     def test_singleton_pattern(self, mock_ldclient):
@@ -100,12 +93,17 @@ def test_singleton_pattern(self, mock_ldclient):
 
         assert mgr1 is mgr2
 
-    def test_singleton_disabled_when_ld_not_configured(self):
+    def test_singleton_raises_when_ld_not_configured(self):
         _make_settings()
-        mgr = FeatureFlagManager.instance()
-        assert mgr.is_enabled() is False
+        with pytest.raises(AttributeError):
+            FeatureFlagManager.instance()
+
+    @patch("dremioai.config.feature_flags.ldclient")
+    def test_singleton_disabled_when_sdk_key_not_set(self, mock_ldclient):
+        mock_client = MagicMock()
+        mock_client.is_initialized.return_value = False
+        mock_ldclient.get.return_value = mock_client
 
-    def test_singleton_disabled_when_sdk_key_not_set(self):
         _make_settings(launchdarkly={})
         mgr = FeatureFlagManager.instance()
         assert mgr.is_enabled() is False
@@ -437,3 +435,34 @@ def test_get_enable_search_with_ld_override(self, mock_ldclient):
         assert cfg.dremio.enable_search is False
         # .get(): LD override
         assert cfg.dremio.get("enable_search") is True
+
+
+class TestLogLevel:
+
+    def test_log_level_default(self):
+        cfg = settings.Settings.model_validate({})
+        assert cfg.log_level == "INFO"
+
+    def test_log_level_from_config(self):
+        cfg = settings.Settings.model_validate({"log_level": "DEBUG"})
+        assert cfg.log_level == "DEBUG"
+
+    def test_log_level_get_without_ld(self):
+        cfg = settings.Settings.model_validate({"log_level": "WARNING"})
+        assert cfg.get("log_level") == "WARNING"
+
+    @patch("dremioai.config.feature_flags.ldclient")
+    def test_log_level_overridden_by_ld(self, mock_ldclient):
+        mock_client = _make_mock_ld_client({"log_level": "ERROR"})
+        mock_ldclient.get.return_value = mock_client
+
+        cfg = _make_settings(launchdarkly={"sdk_key": "test-key"})
+        # Settings._flag_prefix is "" so flag key is just "log_level"
+        assert cfg.get("log_level") == "ERROR"
+        # Direct access returns config value
+        assert cfg.log_level == "INFO"
+
+    def test_log_level_from_env(self, monkeypatch):
+        monkeypatch.setenv("DREMIOAI_LOG_LEVEL", "TRACE")
+        cfg = settings.Settings.model_validate({})
+        assert cfg.log_level == "TRACE"