Add callback on_error handler

Author: T4rk1n

.pylintrc

@@ -414,7 +414,7 @@ max-bool-expr=5
 max-branches=15
 
 # Maximum number of locals for function / method body
-max-locals=20
+max-locals=25
 
 # Maximum number of parents for a class (see R0901).
 max-parents=7

dash/_callback.py

@@ -1,6 +1,7 @@
 import collections
 import hashlib
 from functools import wraps
+from typing import Callable, Optional, Any
 
 import flask
 
@@ -67,6 +68,7 @@ def callback(
     cancel=None,
     manager=None,
     cache_args_to_ignore=None,
+    on_error: Optional[Callable[[Exception], Any]] = None,
     **_kwargs,
 ):
     """
@@ -137,6 +139,10 @@ def callback(
             this should be a list of argument indices as integers.
         :param interval:
             Time to wait between the long callback update requests.
+        :param on_error:
+            Function to call when the callback raises an exception. Receives the
+            exception object as first argument. The callback_context can be used
+            to access the original callback inputs, states and output.
     """
 
     long_spec = None
@@ -186,6 +192,7 @@ def callback(
         long=long_spec,
         manager=manager,
         running=running,
+        on_error=on_error,
     )
 
 
@@ -272,8 +279,8 @@ def insert_callback(
     return callback_id
 
 
-# pylint: disable=R0912, R0915
-def register_callback(  # pylint: disable=R0914
+# pylint: disable=too-many-branches,too-many-statements
+def register_callback(
     callback_list, callback_map, config_prevent_initial_callbacks, *_args, **_kwargs
 ):
     (
@@ -297,6 +304,7 @@ def register_callback(  # pylint: disable=R0914
     long = _kwargs.get("long")
     manager = _kwargs.get("manager")
     running = _kwargs.get("running")
+    on_error = _kwargs.get("on_error")
     if running is not None:
         if not isinstance(running[0], (list, tuple)):
             running = [running]
@@ -342,6 +350,8 @@ def add_context(*args, **kwargs):
                 "callback_context", AttributeDict({"updated_props": {}})
             )
             callback_manager = long and long.get("manager", app_callback_manager)
+            app_on_error = kwargs.pop("app_on_error", None)
+
             if has_output:
                 _validate.validate_output_spec(insert_output, output_spec, Output)
 
@@ -403,6 +413,7 @@ def add_context(*args, **kwargs):
                             triggered_inputs=callback_ctx.triggered_inputs,
                             ignore_register_page=True,
                         ),
+                        on_error=on_error or app_on_error,
                     )
 
                     data = {
@@ -462,7 +473,15 @@ def add_context(*args, **kwargs):
                 if output_value is callback_manager.UNDEFINED:
                     return to_json(response)
             else:
-                output_value = _invoke_callback(func, *func_args, **func_kwargs)
+                try:
+                    output_value = _invoke_callback(func, *func_args, **func_kwargs)
+                except Exception as err:  # pylint: disable=broad-exception-caught
+                    if on_error:
+                        output_value = on_error(err)
+                    elif app_on_error:
+                        output_value = app_on_error(err)
+                    else:
+                        raise err
 
             if NoUpdate.is_no_update(output_value):
                 raise PreventUpdate

dash/dash.py

@@ -16,7 +16,7 @@
 import base64
 import traceback
 from urllib.parse import urlparse
-from typing import Dict, Optional, Union
+from typing import Any, Callable, Dict, Optional, Union
 
 import flask
 
@@ -369,6 +369,10 @@ class Dash:
 
     :param description:  Sets a default description for meta tags on Dash pages (use_pages=True).
 
+    :param on_error: Global callback error handler to call when
+        an exception is raised. Receives the exception object as first argument.
+        The callback_context can be used to access the original callback inputs,
+        states and output.
     """
 
     _plotlyjs_url: str
@@ -409,6 +413,7 @@ def __init__(  # pylint: disable=too-many-statements
         hooks: Union[RendererHooks, None] = None,
         routing_callback_inputs: Optional[Dict[str, Union[Input, State]]] = None,
         description=None,
+        on_error: Optional[Callable[[Exception], Any]] = None,
         **obsolete,
     ):
         _validate.check_obsolete(obsolete)
@@ -520,6 +525,7 @@ def __init__(  # pylint: disable=too-many-statements
         self._layout = None
         self._layout_is_function = False
         self.validation_layout = None
+        self._on_error = on_error
         self._extra_components = []
 
         self._setup_dev_tools()
@@ -1377,6 +1383,7 @@ def dispatch(self):
                     outputs_list=outputs_list,
                     long_callback_manager=self._background_manager,
                     callback_context=g,
+                    app_on_error=self._on_error,
                 )
             )
         )

dash/long_callback/managers/__init__.py

@@ -39,7 +39,7 @@ def job_running(self, job):
     def make_job_fn(self, fn, progress, key=None):
         raise NotImplementedError
 
-    def call_job_fn(self, key, job_fn, args, context):
+    def call_job_fn(self, key, job_fn, args, context, on_error=None):
         raise NotImplementedError
 
     def get_progress(self, key):

dash/long_callback/managers/celery_manager.py

@@ -89,7 +89,7 @@ def get_task(self, job):
     def clear_cache_entry(self, key):
         self.handle.backend.delete(key)
 
-    def call_job_fn(self, key, job_fn, args, context):
+    def call_job_fn(self, key, job_fn, args, context, on_error=None):
         task = job_fn.delay(key, self._make_progress_key(key), args, context)
         return task.task_id
 
@@ -139,7 +139,9 @@ def _make_job_fn(fn, celery_app, progress, key):
     cache = celery_app.backend
 
     @celery_app.task(name=f"long_callback_{key}")
-    def job_fn(result_key, progress_key, user_callback_args, context=None):
+    def job_fn(
+        result_key, progress_key, user_callback_args, context=None, on_error=None
+    ):
         def _set_progress(progress_value):
             if not isinstance(progress_value, (list, tuple)):
                 progress_value = [progress_value]
@@ -161,6 +163,7 @@ def run():
             c.ignore_register_page = False
             c.updated_props = ProxySetProps(_set_props)
             context_value.set(c)
+            errored = False
             try:
                 if isinstance(user_callback_args, dict):
                     user_callback_output = fn(*maybe_progress, **user_callback_args)
@@ -170,25 +173,31 @@ def run():
                     user_callback_output = fn(*maybe_progress, user_callback_args)
             except PreventUpdate:
                 # Put NoUpdate dict directly to avoid circular imports.
+                errored = True
                 cache.set(
                     result_key,
                     json.dumps(
                         {"_dash_no_update": "_dash_no_update"}, cls=PlotlyJSONEncoder
                     ),
                 )
             except Exception as err:  # pylint: disable=broad-except
-                cache.set(
-                    result_key,
-                    json.dumps(
-                        {
-                            "long_callback_error": {
-                                "msg": str(err),
-                                "tb": traceback.format_exc(),
-                            }
-                        },
-                    ),
-                )
-            else:
+                if on_error:
+                    user_callback_output = on_error(err)
+                else:
+                    errored = True
+                    cache.set(
+                        result_key,
+                        json.dumps(
+                            {
+                                "long_callback_error": {
+                                    "msg": str(err),
+                                    "tb": traceback.format_exc(),
+                                }
+                            },
+                        ),
+                    )
+
+            if not errored:
                 cache.set(
                     result_key, json.dumps(user_callback_output, cls=PlotlyJSONEncoder)
                 )

dash/long_callback/managers/diskcache_manager.py

@@ -115,13 +115,14 @@ def clear_cache_entry(self, key):
         self.handle.delete(key)
 
     # noinspection PyUnresolvedReferences
-    def call_job_fn(self, key, job_fn, args, context):
+    def call_job_fn(self, key, job_fn, args, context, on_error=None):
         # pylint: disable-next=import-outside-toplevel,no-name-in-module,import-error
         from multiprocess import Process
 
         # pylint: disable-next=not-callable
         proc = Process(
-            target=job_fn, args=(key, self._make_progress_key(key), args, context)
+            target=job_fn,
+            args=(key, self._make_progress_key(key), args, context, on_error),
         )
         proc.start()
         return proc.pid
@@ -168,7 +169,7 @@ def get_updated_props(self, key):
 
 
 def _make_job_fn(fn, cache, progress):
-    def job_fn(result_key, progress_key, user_callback_args, context):
+    def job_fn(result_key, progress_key, user_callback_args, context, on_error):
         def _set_progress(progress_value):
             if not isinstance(progress_value, (list, tuple)):
                 progress_value = [progress_value]
@@ -187,6 +188,7 @@ def run():
             c.ignore_register_page = False
             c.updated_props = ProxySetProps(_set_props)
             context_value.set(c)
+            errored = False
             try:
                 if isinstance(user_callback_args, dict):
                     user_callback_output = fn(*maybe_progress, **user_callback_args)
@@ -195,18 +197,24 @@ def run():
                 else:
                     user_callback_output = fn(*maybe_progress, user_callback_args)
             except PreventUpdate:
+                errored = True
                 cache.set(result_key, {"_dash_no_update": "_dash_no_update"})
             except Exception as err:  # pylint: disable=broad-except
-                cache.set(
-                    result_key,
-                    {
-                        "long_callback_error": {
-                            "msg": str(err),
-                            "tb": traceback.format_exc(),
-                        }
-                    },
-                )
-            else:
+                if on_error:
+                    user_callback_output = on_error(err)
+                else:
+                    errored = True
+                    cache.set(
+                        result_key,
+                        {
+                            "long_callback_error": {
+                                "msg": str(err),
+                                "tb": traceback.format_exc(),
+                            }
+                        },
+                    )
+
+            if not errored:
                 cache.set(result_key, user_callback_output)
 
         ctx.run(run)

tests/integration/callbacks/test_callback_error.py

@@ -0,0 +1,43 @@
+from dash import Dash, html, Input, Output
+
+
+def test_cber001_error_handler(dash_duo):
+    def global_callback_error_handler(err):
+        return f"global: {err}"
+
+    app = Dash(on_error=global_callback_error_handler)
+
+    app.layout = [
+        html.Button("start", id="start-local"),
+        html.Button("start-global", id="start-global"),
+        html.Div(id="output"),
+        html.Div(id="output-global"),
+    ]
+
+    def on_callback_error(err):
+        return f"callback: {err}"
+
+    @app.callback(
+        Output("output", "children"),
+        Input("start-local", "n_clicks"),
+        on_error=on_callback_error,
+        prevent_initial_call=True,
+    )
+    def on_start(_):
+        raise Exception("local error")
+
+    @app.callback(
+        Output("output-global", "children"),
+        Input("start-global", "n_clicks"),
+        prevent_initial_call=True,
+    )
+    def on_start_global(_):
+        raise Exception("global error")
+
+    dash_duo.start_server(app)
+    dash_duo.find_element("#start-local").click()
+
+    dash_duo.wait_for_text_to_equal("#output", "callback: local error")
+
+    dash_duo.find_element("#start-global").click()
+    dash_duo.wait_for_text_to_equal("#output-global", "global: global error")

tests/integration/long_callback/app_bg_on_error.py

@@ -0,0 +1,51 @@
+from dash import Dash, Input, Output, html
+from tests.integration.long_callback.utils import get_long_callback_manager
+
+long_callback_manager = get_long_callback_manager()
+handle = long_callback_manager.handle
+
+
+def global_error_handler(err):
+
+    return f"global: {err}"
+
+
+app = Dash(
+    __name__, long_callback_manager=long_callback_manager, on_error=global_error_handler
+)
+
+app.layout = [
+    html.Button("callback on_error", id="start-cb-onerror"),
+    html.Div(id="cb-output"),
+    html.Button("global on_error", id="start-global-onerror"),
+    html.Div(id="global-output"),
+]
+
+
+def callback_on_error(err):
+    return f"callback: {err}"
+
+
+@app.callback(
+    Output("cb-output", "children"),
+    Input("start-cb-onerror", "n_clicks"),
+    prevent_initial_call=True,
+    background=True,
+    on_error=callback_on_error,
+)
+def on_click(_):
+    raise Exception("callback error")
+
+
+@app.callback(
+    Output("global-output", "children"),
+    Input("start-global-onerror", "n_clicks"),
+    prevent_initial_call=True,
+    background=True,
+)
+def on_click_global(_):
+    raise Exception("global error")
+
+
+if __name__ == "__main__":
+    app.run(debug=True)