feat: support logging of exceptions

Author: Izaak Gough

src/firebase_functions/logger.py

@@ -6,6 +6,7 @@
 import json as _json
 import sys as _sys
 import typing as _typing
+import traceback as _traceback
 
 import typing_extensions as _typing_extensions
 
@@ -71,6 +72,43 @@ def _entry_from_args(severity: LogSeverity, *args, **kwargs) -> LogEntry:
     return _typing.cast(LogEntry, entry)
 
 
+def _exception_from_args(
+    exception: BaseException, refs: set[_typing.Any] | None = None
+) -> dict[str, _typing.Any]:
+    """
+    Creates a JSON-safe representation of an exception.
+    """
+
+    details: dict[str, _typing.Any] = {
+        "type": exception.__class__.__name__,
+        "message": _safe_exception_string(exception),
+    }
+    if exception.args:
+        details["args"] = _remove_circular(exception.args, refs)
+    if exception.__traceback__ is not None:
+        try:
+            details["stack_trace"] = "".join(
+                _traceback.format_exception(
+                    exception.__class__, exception, exception.__traceback__
+                )
+            )
+        except Exception:
+            details["stack_trace"] = "".join(_traceback.format_tb(exception.__traceback__))
+            details["stack_trace"] += f"{exception.__class__.__name__}: {details['message']}\n"
+    return details
+
+
+def _safe_exception_string(exception: BaseException) -> str:
+    """
+    Returns a string representation of an exception without propagating repr/str errors.
+    """
+
+    try:
+        return str(exception)
+    except Exception:
+        return exception.__class__.__name__
+
+
 def _remove_circular(obj: _typing.Any, refs: set[_typing.Any] | None = None):
     """
     Removes circular references from the given object and replaces them with "[CIRCULAR]".
@@ -89,7 +127,9 @@ def _remove_circular(obj: _typing.Any, refs: set[_typing.Any] | None = None):
 
     # Recursively process the object based on its type
     result: _typing.Any
-    if isinstance(obj, dict):
+    if isinstance(obj, BaseException):
+        result = _exception_from_args(obj, refs)
+    elif isinstance(obj, dict):
         result = {key: _remove_circular(value, refs) for key, value in obj.items()}
     elif isinstance(obj, list):
         result = [_remove_circular(item, refs) for item in obj]
@@ -149,3 +189,16 @@ def error(*args, **kwargs) -> None:
     Logs an error message.
     """
     write(_entry_from_args(LogSeverity.ERROR, *args, **kwargs))
+
+
+def exception(*args, **kwargs) -> None:
+    """
+    Logs an error message and includes the active stack trace.
+    """
+    entry = _entry_from_args(LogSeverity.ERROR, *args, **kwargs)
+    exc_type, exc_value, exc_traceback = _sys.exc_info()
+    if exc_type is not None and exc_value is not None and exc_traceback is not None:
+        entry["stack_trace"] = "".join(
+            _traceback.format_exception(exc_type, exc_value, exc_traceback)
+        )
+    write(entry)

tests/test_logger.py

@@ -59,6 +59,56 @@ def test_severity_should_be_error(self, capsys: pytest.CaptureFixture[str]):
         log_output = json.loads(raw_log_output)
         assert log_output["severity"] == "ERROR"
 
+    def test_error_should_accept_exception(self, capsys: pytest.CaptureFixture[str]):
+        try:
+            raise ValueError("boom")
+        except ValueError as exception:
+            logger.error("failed", error=exception)
+
+        raw_log_output = capsys.readouterr().err
+        log_output = json.loads(raw_log_output)
+
+        assert log_output["severity"] == "ERROR"
+        assert log_output["message"] == "failed"
+        assert log_output["error"]["type"] == "ValueError"
+        assert log_output["error"]["message"] == "boom"
+        assert "stack_trace" in log_output["error"]
+        assert "ValueError: boom" in log_output["error"]["stack_trace"]
+
+    def test_error_should_accept_self_referential_exception(self, capsys: pytest.CaptureFixture[str]):
+        class SelfArgError(Exception):
+            pass
+
+        exception = SelfArgError("boom")
+        exception.args = (exception,)
+
+        logger.error("failed", error=exception)
+
+        raw_log_output = capsys.readouterr().err
+        log_output = json.loads(raw_log_output)
+
+        assert log_output["severity"] == "ERROR"
+        assert log_output["message"] == "failed"
+        assert log_output["error"]["type"] == "SelfArgError"
+        assert log_output["error"]["args"] == ["[CIRCULAR]"]
+
+    def test_error_should_accept_exception_with_cyclic_payload(
+        self, capsys: pytest.CaptureFixture[str]
+    ):
+        payload = {}
+        payload["self"] = payload
+        exception = ValueError(payload)
+
+        logger.error("failed", error=exception)
+
+        raw_log_output = capsys.readouterr().err
+        log_output = json.loads(raw_log_output)
+
+        assert log_output["severity"] == "ERROR"
+        assert log_output["message"] == "failed"
+        assert log_output["error"]["type"] == "ValueError"
+        assert log_output["error"]["args"] == [{"self": "[CIRCULAR]"}]
+
     def test_log_should_have_message(self, capsys: pytest.CaptureFixture[str]):
         logger.log("bar")
         raw_log_output = capsys.readouterr().out
@@ -78,6 +128,20 @@ def test_message_should_be_space_separated(self, capsys: pytest.CaptureFixture[s
         log_output = json.loads(raw_log_output)
         assert log_output["message"] == expected_message
 
+    def test_exception_should_include_stack_trace(self, capsys: pytest.CaptureFixture[str]):
+        try:
+            raise ValueError("boom")
+        except ValueError:
+            logger.exception("failed")
+
+        raw_log_output = capsys.readouterr().err
+        log_output = json.loads(raw_log_output)
+
+        assert log_output["severity"] == "ERROR"
+        assert log_output["message"] == "failed"
+        assert "stack_trace" in log_output
+        assert "ValueError: boom" in log_output["stack_trace"]
+
     def test_remove_circular_references(self, capsys: pytest.CaptureFixture[str]):
         # Create an object with a circular reference.
         circ = {"b": "foo"}