GitLab Well Architected
Cookbook navigation

Example: find the error a settings loader hides

Your application keeps reverting to the light theme, even though you saved a different preference. A settings loader might be hiding the error that would explain why. You can ask Duo to compare the loaders, then try a few settings files to see whether its explanation matches what happens.

Give Duo both loaders and a caller

In GitLab Duo Chat, copy the prompt from the previous page and replace [TYPE OF ERROR] with a settings file that's missing or can't be read. Include this code so Duo can see both functions and how the application uses the result:

import json
import logging

logging.basicConfig(level=logging.INFO, format="%(levelname)s: %(message)s")
logger = logging.getLogger(__name__)


def load_settings(path):
    """Return saved settings, or None when the file doesn't exist yet."""
    try:
        with open(path, encoding="utf-8") as file:
            return json.load(file)
    except FileNotFoundError:
        logger.info("No settings file at %s; using defaults", path)
        return None


def load_theme(path):
    """Return the saved theme name, or None when no theme is saved."""
    try:
        with open(path, encoding="utf-8") as file:
            return json.load(file)["theme"]
    except Exception:
        return None


# At startup, the application falls back to the light theme.
theme = load_theme("settings.json") or "light"

The last line shows Duo how the application falls back to the light theme. A missing file is expected when someone hasn't saved their preferences yet, so a change that raises an exception there would prevent the application from starting.

Compare the answer with what the code does

With Python 3 installed, save the code above as settings.py in a new folder. Save the following alongside it as try_settings.py. It creates temporary settings files, calls both loaders, and removes the files when it finishes:

from pathlib import Path
from tempfile import TemporaryDirectory

from settings import load_settings, load_theme

cases = {
    "missing": None,
    "saved theme": '{"theme": "dark"}',
    "empty object": '{}',
    "malformed": '{"theme": "dark"',
    "misspelled key": '{"them": "dark"}',
    "array": '[]',
    "null": 'null',
}

with TemporaryDirectory() as directory:
    for name, content in cases.items():
        path = Path(directory) / f"{name}.json"
        if content is not None:
            path.write_text(content, encoding="utf-8")
        print(f"\n{name}:")
        for loader in (load_settings, load_theme):
            try:
                result = repr(loader(path))
            except Exception as error:
                # Keep going so one failed read doesn't hide the other results.
                result = f"raises {type(error).__name__}"
            print(f"  {loader.__name__}: {result}")

From that folder, run:

python3 try_settings.py

Compare the results with Duo's explanation. The INFO logging setting makes the missing-file message visible; the returned values and exceptions should match this table:

Settings file load_settings load_theme
Doesn't exist None, with a log line None
{"theme": "dark"} {'theme': 'dark'} 'dark'
{} {} None
{"theme": "dark" (missing }) Raises JSONDecodeError None
{"them": "dark"} (misspelled) {'them': 'dark'} None
[] (not an object) [] None
null (not an object) None None

Both functions return None when the file is missing. For other errors, load_theme catches every Exception and returns None without logging it. A broken settings file, a misspelled key, JSON that isn't an object, or a file the application can't read can all make your dark theme disappear without an explanation.

For malformed JSON, load_settings raises an exception while load_theme quietly returns None. Duo can explain that difference, but it can't tell whether you wanted startup to stop or continue with the default theme. If it recommends one approach, ask what would happen with the other.

If Duo says the handlers are consistent, point it to the malformed-file result. Custom exceptions or a retry strategy would be possible changes to discuss; if they appear in the explanation, ask Duo to clarify that the supplied code doesn't implement them.

Ask for a change that keeps the caller working

Continue the conversation with a follow-up:

The startup code depends on None meaning "use the default theme." Change
load_theme so a malformed settings file is no longer silent, without
breaking that caller. What else would behave differently after your change?

Here's one way to keep the default theme while making broken settings visible. Replace load_theme in settings.py with this version:

def load_theme(path):
    """Return the saved theme name, or None when no theme is saved."""
    try:
        with open(path, encoding="utf-8") as file:
            settings = json.load(file)
    except FileNotFoundError:
        logger.info("No settings file at %s; using defaults", path)
        return None
    except json.JSONDecodeError:
        logger.warning("Settings file at %s isn't valid JSON; using the default theme", path)
        return None
    if not isinstance(settings, dict):
        logger.warning("Settings file at %s doesn't contain a JSON object; using the default theme", path)
        return None
    return settings.get("theme")

Run python3 try_settings.py again. The returned values from load_theme stay the same, but the malformed file, [], and null now produce warnings. A missing file still produces an INFO message and uses the default theme.

This version reads the file directly because load_settings returns None for both a missing file and JSON null. Handling the missing file separately lets us warn about null: the file exists, but it doesn't contain the settings object we expected.

Try Duo's version with the same files too. Without the object check, settings.get("theme") raises AttributeError for [] or null, where the original loader returned None. If that happens, share the file contents and error with Duo and ask it to keep startup working. Catching fewer exceptions makes failures easier to see, but it can also expose cases the old handler was hiding.

What if the file exists but the application isn't allowed to read it? The version above lets PermissionError stop startup. You might prefer to catch OSError, log a warning, and continue with the default theme instead. Whether the application can work without those settings will help you choose. Ask Duo to explain what its version does before adopting it; the temporary files above don't exercise file permissions.

Notice what's still silent

The misspelled key still returns None without a warning. Neither loader knows whether them is a typo or an unrelated setting. You could ask Duo to warn about unrecognized keys, but consider whether the application also reads settings written by other versions before rejecting those keys outright.

There's another choice in the startup line: load_theme(...) or "light" replaces an empty theme name, "", with the default too. If an empty name means something different from a missing theme in your application, comparing the result with None keeps the two cases apart.

When you use the prompt on your own code, include at least two places that handle the same error, along with a caller that depends on the result. Differences between the handlers are where the inconsistencies show up, and the caller shows which ones matter.

Back to the prompt