feat: add warning reporting functionality to error handler and no longer crash if JS context destroyed when calling function

Author: std-microblock

src/shell/error_handler.cc

@@ -110,6 +110,19 @@ void mb_shell::install_error_handlers() {
     g_previous_sigabrt_handler = signal(SIGABRT, handle_sigabrt);
 }
 
+void mb_shell::report_warning(const char* message) {
+    sentry_value_t event = sentry_value_new_event();
+    sentry_value_set_by_key(event, "level", sentry_value_new_string("warning"));
+
+    sentry_value_t exc = sentry_value_new_exception("Warning", message);
+    sentry_value_t stacktrace = sentry_value_new_stacktrace(nullptr, 0);
+    sentry_value_set_by_key(exc, "stacktrace", stacktrace);
+    sentry_value_set_by_key(event, "exception", sentry_value_new_list());
+    sentry_value_append(sentry_value_get_by_key(event, "exception"), exc);
+
+    sentry_capture_event(event);
+}
+
 void mb_shell::cleanup_error_handlers() {
     if (g_previous_sigabrt_handler) {
         signal(SIGABRT, g_previous_sigabrt_handler);

src/shell/error_handler.h

@@ -1,5 +1,13 @@
 #pragma once
+#include <fmt/format.h>
+
 namespace mb_shell {
 void install_error_handlers();
 void cleanup_error_handlers();
+void report_warning(const char* message);
+
+template<typename... Args>
+void report_warning(fmt::format_string<Args...> fmt, Args&&... args) {
+    report_warning(fmt::format(fmt, std::forward<Args>(args)...).c_str());
+}
 }

src/shell/script/quickjspp.hpp

@@ -1,6 +1,7 @@
 #pragma once
 
 #include "quickjs.h"
+#include "../error_handler.h"
 
 #include <algorithm>
 #include <atomic>
@@ -1961,8 +1962,14 @@ struct js_traits<std::function<R(Args...)>, int> {
         return
             [jsfun_obj = Value{weakFromContext(ctx), JS_DupValue(ctx, fun_obj)},
              weak](Args... args) -> R {
-                if (weak.expired())
-                    throw qjs_context_destroyed_exception{};
+                if (weak.expired()) {
+                    mb_shell::report_warning("JS context destroyed when calling function");
+                    if constexpr (!std::is_void_v<R>) {
+                        return R{};
+                    } else {
+                        return;
+                    }
+                }
                 auto &ctx = Context::get(jsfun_obj.ctx);
                 std::promise<std::expected<JSValue, exception>> promise;
                 auto future = promise.get_future();