``FALLBACK_ERROR_FORMAT`` cannot be set even when the ``update_config`` function is called because the ``ErrorHandler`` object receives the default value of the config and is initialized.

[SaidBySolo]

Describe the bug

sanic/sanic/app.py

Lines 139 to 184 in 3262878

	def __init__(
	self,
	name: str = None,
	config: Optional[Config] = None,
	ctx: Optional[Any] = None,
	router: Optional[Router] = None,
	signal_router: Optional[SignalRouter] = None,
	error_handler: Optional[ErrorHandler] = None,
	load_env: Union[bool, str] = True,
	env_prefix: Optional[str] = SANIC_PREFIX,
	request_class: Optional[Type[Request]] = None,
	strict_slashes: bool = False,
	log_config: Optional[Dict[str, Any]] = None,
	configure_logging: bool = True,
	register: Optional[bool] = None,
	dumps: Optional[Callable[..., AnyStr]] = None,
	) -> None:
	super().__init__(name=name)
	# logging
	if configure_logging:
	logging.config.dictConfig(log_config or LOGGING_CONFIG_DEFAULTS)
	if config and (load_env is not True or env_prefix != SANIC_PREFIX):
	raise SanicException(
	"When instantiating Sanic with config, you cannot also pass "
	"load_env or env_prefix"
	)
	self._asgi_client = None
	self._blueprint_order: List[Blueprint] = []
	self._delayed_tasks: List[str] = []
	self._test_client = None
	self._test_manager = None
	self.asgi = False
	self.auto_reload = False
	self.blueprints: Dict[str, Blueprint] = {}
	self.config = config or Config(
	load_env=load_env, env_prefix=env_prefix
	)
	self.configure_logging = configure_logging
	self.ctx = ctx or SimpleNamespace()
	self.debug = None
	self.error_handler = error_handler or ErrorHandler(
	fallback=self.config.FALLBACK_ERROR_FORMAT,
	)

Referring to the code above, since the config is set when the Sanic object is initialized, you cannot pass a fallback value to the ErrorHandler even if you set config.update_config or app.config.FALLBACK_ERROR_FORMAT = "json".

To solve this, you can pass the config argument when initializing the Sanic app, but this doesn't seem to be intended.

Code snippet

app = Sanic(__name__)

@app.main_process_start
async def start(app, loop):
    app.config.FALLBACK_ERROR_FORMAT = "json"

Expected behavior
Even if you use config.update_config or app.config.FALLBACK_ERROR_FORMAT = "json", the error handler should normally receive this value.

Environment (please complete the following information):

• OS: [Windows 10]
• Version [21.9.1]

Additional context

I wanted to open a PR on this issue, but I'm not sure where to touch.

[prryplatypus]

Seems to have been introduced in #2162. In the meantime you should be able to work around it by setting app.error_handler.fallback to whatever fallback format you would like.

[prryplatypus]

@ahopkins, how would you like to fix this one? I guess the simplest way would be to just do this, but that could lead to inconsistent behaviour depending on the initialisation config value (which is what's causing this issue in the first place).

sanic/sanic/errorpages.py

Lines 386 to 394 in 392a497

	if not renderer:
	# Make sure we have something set
	renderer = base
	render_format = fallback
	if request:
	# If there is a request, try and get the format
	# from the route
	if request.route:

    if not renderer:
        # Make sure we have something set
        renderer = base
        render_format = fallback

        if request:
+           render_format = request.app.config.FALLBACK_ERROR_FORMAT
            # If there is a request, try and get the format
            # from the route
            if request.route:

[ahopkins]

Yeah, there is a very delicate balance in that function to finding the right format. I am not sure that I would want to add that layer there. It really should be set on the error_handler object like in your suggestion.

TBH, we really need to be hikacking the setter. Which, admittedly is something we do only some of the time. This can lead to inconsistencies and is something we should probably address.

I think the best solution is to catch this in the setter (whether as an object or a dict) and to update the value on the error handler as in your suggestion above. I would also suggest that if the error handler is not already the default value, then maybe we throw a warning that it is being overridden. You might be able to see where this slippery slope is going. The question then is what happens if the error handler was specifically set to the value that happens to be the default? In that case, maybe it needs to default to a sentinel value then be updated at startup in the finalization.

---

So, after all that, I think the way to handle it is like this:

1. Take the initialization time injection out:

--- a/sanic/app.py
+++ b/sanic/app.py
@@ -195,9 +195,7 @@ class Sanic(BaseSanic, metaclass=TouchUpMeta):
         self.configure_logging: bool = configure_logging
         self.ctx: Any = ctx or SimpleNamespace()
         self.debug = False
-        self.error_handler: ErrorHandler = error_handler or ErrorHandler(
-            fallback=self.config.FALLBACK_ERROR_FORMAT,
-        )
+        self.error_handler: ErrorHandler = error_handler or ErrorHandler()

2. Instead, add it here:

@@ -1627,7 +1625,9 @@ class Sanic(BaseSanic, metaclass=TouchUpMeta):
     async def _startup(self):
         self.signalize()
         self.finalize()
-        ErrorHandler.finalize(self.error_handler)
+        ErrorHandler.finalize(
+            self.error_handler, fallback=self.config.FALLBACK_ERROR_FORMAT
+        )

3. Set the default to our _default sentinel. Then in ErrorHandler.finalize we can check if the value was changed (in which case we can throw up a warning or error).

This method should be backwards compat.