Force everything to a string if it can't be serialized.

The alternative here is to inspect and iterate over every collection and
object passed around. This avoids having to reinvent the wheel in that
scenario.

Author: tim-schilling

debug_toolbar/settings.py

@@ -37,7 +37,6 @@
     "PROFILER_CAPTURE_PROJECT_CODE": True,
     "PROFILER_MAX_DEPTH": 10,
     "PROFILER_THRESHOLD_RATIO": 8,
-    "SUPPRESS_SERIALIZATION_ERRORS": True,
     "SHOW_TEMPLATE_CONTEXT": True,
     "SKIP_TEMPLATE_PREFIXES": ("django/forms/widgets/", "admin/widgets/"),
     "SQL_WARNING_THRESHOLD": 500,  # milliseconds

debug_toolbar/store.py

@@ -5,18 +5,28 @@
 from typing import Any, Dict, Iterable
 
 from django.core.serializers.json import DjangoJSONEncoder
+from django.utils.encoding import force_str
 from django.utils.module_loading import import_string
 
 from debug_toolbar import settings as dt_settings
 
 logger = logging.getLogger(__name__)
 
 
+class DebugToolbarJSONEncoder(DjangoJSONEncoder):
+    def default(self, o):
+        try:
+            return super().default(o)
+        except (TypeError, ValueError):
+            logger.debug("The debug toolbar can't serialize %s into JSON" % o)
+            return force_str(o)
+
+
 def serialize(data: Any) -> str:
     # If this starts throwing an exceptions, consider
     # Subclassing DjangoJSONEncoder and using force_str to
     # make it JSON serializable.
-    return json.dumps(data, cls=DjangoJSONEncoder)
+    return json.dumps(data, cls=DebugToolbarJSONEncoder)
 
 
 def deserialize(data: str) -> Any:
@@ -106,14 +116,7 @@ def delete(cls, request_id: str):
     def save_panel(cls, request_id: str, panel_id: str, data: Any = None):
         """Save the panel data for the given request_id"""
         cls.set(request_id)
-        try:
-            cls._request_store[request_id][panel_id] = serialize(data)
-        except TypeError:
-            if dt_settings.get_config()["SUPPRESS_SERIALIZATION_ERRORS"]:
-                log = "Panel (%s) failed to serialized data %s properly."
-                logger.warning(log % (panel_id, data))
-            else:
-                raise
+        cls._request_store[request_id][panel_id] = serialize(data)
 
     @classmethod
     def panel(cls, request_id: str, panel_id: str) -> Any:

docs/changes.rst

@@ -7,8 +7,6 @@ Serializable (don't include in main)
 * Defines the ``BaseStore`` interface for request storage mechanisms.
 * Added the setting ``TOOLBAR_STORE_CLASS`` to configure the request
   storage mechanism. Defaults to ``debug_toolbar.store.MemoryStore``.
-* Added setting ``SUPPRESS_SERIALIZATION_ERRORS`` to suppress
-  warnings when a ``TypeError`` occurs during a panel's serialization.
 * Rename ``store_id`` properties to ``request_id`` and ``Toolbar.store`` to
   ``Toolbar.init_store``.
 * Support ``Panel`` instances with stored stats via

docs/configuration.rst

@@ -306,15 +306,6 @@ Panel options
   the nested functions. The threshold is calculated by the root calls'
   cumulative time divided by this ratio.
 
-* ``SUPPRESS_SERIALIZATION_ERRORS``
-
-  Default: ``True``
-
-  If set to ``True`` then panels will log a warning if a ``TypeError`` is
-  raised when attempting to serialize a panel's stats rather than raising an
-  exception.. If set to ``False`` then the ``TypeError`` will be raised. The
-  default will eventually be set to ``False`` and removed entirely.
-
 * ``SHOW_TEMPLATE_CONTEXT``
 
   Default: ``True``

tests/test_store.py

@@ -1,5 +1,3 @@
-import logging
-
 from django.test import TestCase
 from django.test.utils import override_settings
 
@@ -95,21 +93,6 @@ def test_save_panel(self):
         self.assertEqual(list(self.store.request_ids()), ["bar"])
         self.assertEqual(self.store.panel("bar", "bar.panel"), {"a": 1})
 
-    def test_save_panel_serialization_warning(self):
-        """The store should warn the user about a serialization error."""
-        self.assertLogs()
-
-        with self.assertLogs("debug_toolbar.store", level=logging.WARNING) as logs:
-            self.store.save_panel("bar", "bar.panel", {"value": {"foo"}})
-
-        self.assertEqual(
-            logs.output,
-            [
-                "WARNING:debug_toolbar.store:Panel (bar.panel) failed to "
-                "serialized data {'value': {'foo'}} properly."
-            ],
-        )
-
     def test_panel(self):
         self.assertEqual(self.store.panel("missing", "missing"), {})
         self.store.save_panel("bar", "bar.panel", {"a": 1})