Align tests with simplified FlagAwareMixin and safe FeatureFlagManager.instance()

- FlagAwareMixin.get() now uses _flag_prefix when calling get_flag
- FeatureFlagManager.instance() gracefully handles missing LD config
  (catches AttributeError/TypeError, passes sdk_key=None)
- Tests updated: singleton test expects disabled manager instead of
  exception, get_flag calls use positional args

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

Author: aniket-s-kulkarni

src/dremioai/config/feature_flags.py

@@ -13,6 +13,7 @@
 #  See the License for the specific language governing permissions and
 #  limitations under the License.
 #
+import logging
 from typing import Optional, Any, Self, ClassVar
 from dremioai import log
 import ldclient
@@ -26,25 +27,31 @@ class FeatureFlagManager:
     _instance: ClassVar[Self] = None
 
     def __init__(self, sdk_key: str):
-        try:
+        if sdk_key is not None:
+            self._log.info(
+                f"Initializing LaunchDarkly client with SDK key: {len(sdk_key)} bytes"
+            )
             ldclient.set_config(Config(sdk_key))
             self._client = ldclient.get()
 
             if self._client.is_initialized():
                 self._log.info("LaunchDarkly client initialized successfully")
             else:
                 self._log.warning("LaunchDarkly client initialization pending")
-        except:
-            self._log.exception(f"Failed to initialize LaunchDarkly client")
-            raise
+        else:
+            self._client = None
 
     @classmethod
     def instance(cls) -> Self:
         """Lazily initializes from settings.instance().dremio.launchdarkly.sdk_key."""
         if cls._instance is None:
             from dremioai.config import settings
 
-            sdk_key = settings.instance().dremio.launchdarkly.sdk_key
+            sdk_key = None
+            try:
+                sdk_key = settings.instance().dremio.launchdarkly.sdk_key
+            except (AttributeError, TypeError):
+                pass
             cls._instance = cls(sdk_key)
         return cls._instance
 
@@ -59,8 +66,12 @@ def is_enabled(self) -> bool:
 
     def get_flag(self, flag_key: str, default: Any) -> Any:
         if not self.is_enabled():
-            self._log.debug(
-                f"Flag '{flag_key}' not evaluated, LaunchDarkly not enabled/initialized (default: {default})"
+            state, level = "enabled", logging.DEBUG
+            if self._client is not None:
+                state, level = "initialized", logging.WARNING
+            self._log.log(
+                level,
+                f"Flag '{flag_key}' not evaluated, LaunchDarkly not {state}",
             )
             return default
         value = self._client.variation(

src/dremioai/config/settings.py

@@ -63,11 +63,7 @@ class GetterMixin:
     Use with BaseModel or BaseSettings via multiple inheritance.
     """
 
-    def get(self, field_name: str, default: Any = None):
-        if not hasattr(self, field_name):
-            raise AttributeError(
-                f"'{type(self).__name__}' has no attribute '{field_name}'"
-            )
+    def get(self, field_name: str):
         return getattr(self, field_name)
 
 
@@ -84,20 +80,11 @@ def get(self, field_name: str, default: Any = None):
 class FlagAwareMixin(GetterMixin):
     _flag_prefix: str = ""
 
-    def get(self, field_name: str, default: Any = None):
-        if not hasattr(self, field_name):
-            raise AttributeError(
-                f"'{type(self).__name__}' has no attribute '{field_name}'"
-            )
-        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:
-                return flag
-        return super().get(field_name, default)
+    def get(self, field_name: str):
+        key = f"{self._flag_prefix}.{field_name}" if self._flag_prefix else field_name
+        return FeatureFlagManager.instance().get_flag(
+            key, super().get(field_name)
+        )
 
 
 # Convenience base for sub-models that need both FlagAwareMixin and BaseModel.
@@ -410,7 +397,7 @@ def _propagate_flag_prefixes(obj, prefix: str):
         child = getattr(obj, name, None)
         if isinstance(child, FlagAwareMixin):
             child_prefix = f"{prefix}.{name}" if prefix else name
-            object.__setattr__(child, '_flag_prefix', child_prefix)
+            object.__setattr__(child, "_flag_prefix", child_prefix)
             _propagate_flag_prefixes(child, child_prefix)
 
 

tests/config/test_launchdarkly_integration.py

@@ -62,15 +62,15 @@ def test_get_flag_returns_ld_value(self, mock_ldclient):
         mock_ldclient.get.return_value = mock_client
 
         mgr = FeatureFlagManager("test-sdk-key")
-        assert mgr.get_flag("my_flag", default=False) is True
+        assert mgr.get_flag("my_flag", False) is True
 
     @patch("dremioai.config.feature_flags.ldclient")
     def test_get_flag_returns_default_when_not_found(self, mock_ldclient):
         mock_client = _make_mock_ld_client({})
         mock_ldclient.get.return_value = mock_client
 
         mgr = FeatureFlagManager("test-sdk-key")
-        assert mgr.get_flag("unknown_flag", default="fallback") == "fallback"
+        assert mgr.get_flag("unknown_flag", "fallback") == "fallback"
 
     @patch("dremioai.config.feature_flags.ldclient")
     def test_get_flag_returns_default_when_not_initialized(self, mock_ldclient):
@@ -79,7 +79,7 @@ def test_get_flag_returns_default_when_not_initialized(self, mock_ldclient):
         mock_ldclient.get.return_value = mock_client
 
         mgr = FeatureFlagManager("test-sdk-key")
-        assert mgr.get_flag("any_flag", default="fallback") == "fallback"
+        assert mgr.get_flag("any_flag", "fallback") == "fallback"
 
     @patch("dremioai.config.feature_flags.ldclient")
     def test_singleton_pattern(self, mock_ldclient):
@@ -93,10 +93,10 @@ def test_singleton_pattern(self, mock_ldclient):
 
         assert mgr1 is mgr2
 
-    def test_singleton_raises_when_ld_not_configured(self):
+    def test_singleton_disabled_when_ld_not_configured(self):
         _make_settings()
-        with pytest.raises(AttributeError):
-            FeatureFlagManager.instance()
+        mgr = FeatureFlagManager.instance()
+        assert mgr.is_enabled() is False
 
     @patch("dremioai.config.feature_flags.ldclient")
     def test_singleton_disabled_when_sdk_key_not_set(self, mock_ldclient):