Move to a separate header file and rename to SAFELY

include/mongoose.hrl

@@ -31,13 +31,6 @@
 
 -define(MONGOOSE_URI, <<"https://www.erlang-solutions.com/products/mongooseim.html">>).
 
--define(APPLY_SAFELY(F),
-        try F catch
-            error:R:S -> {exception, #{class => error, reason => R, stacktrace => S}};
-            throw:R -> {exception, #{class => throw, reason => R}};
-            exit:R:S -> {exception, #{class => exit, reason => R, stacktrace => S}}
-        end).
-
 %% ---------------------------------
 %% Logging mechanism
 -include("mongoose_logger.hrl").

include/safely.hrl

@@ -0,0 +1,11 @@
+-ifndef(SAFELY).
+-define(SAFELY, true).
+
+-define(SAFELY(F),
+        try F catch
+            error:R:S -> {exception, #{class => error, reason => R, stacktrace => S}};
+            throw:R -> {exception, #{class => throw, reason => R}};
+            exit:R:S -> {exception, #{class => exit, reason => R, stacktrace => S}}
+        end).
+
+-endif.

src/gen_hook.erl

@@ -23,6 +23,7 @@
 
 -ignore_xref([start_link/0, add_handlers/1, delete_handlers/1]).
 
+-include("safely.hrl").
 -include("mongoose.hrl").
 
 -type hook_name() :: atom().
@@ -227,7 +228,7 @@ run_hook([Handler | Ls], Acc, Params, Key) ->
     hook_fn_ret() | safely:exception().
 apply_hook_function(#hook_handler{hook_fn = HookFn, extra = Extra},
                     Acc, Params) ->
-    ?APPLY_SAFELY(HookFn(Acc, Params, Extra)).
+    ?SAFELY(HookFn(Acc, Params, Extra)).
 
 error_running_hook(Info, Handler, Acc, Params, Key) ->
     ?LOG_ERROR(Info#{what => hook_failed,

src/safely.erl

@@ -7,7 +7,7 @@
 %% If it is an error, we want the stacktrace, if not, we don't.
 %% For more information, see usage in test/safely_SUITE.erl
 
--include("mongoose.hrl").
+-include("safely.hrl").
 -include_lib("kernel/include/logger.hrl").
 
 -ifdef(TEST).
@@ -40,11 +40,11 @@
 -ifdef(TEST).
 -spec apply(fun((...) -> A), [term()]) -> A | exception().
 apply(Function, Args) when is_function(Function), is_list(Args) ->
-    ?APPLY_SAFELY(erlang:apply(Function, Args)).
+    ?SAFELY(erlang:apply(Function, Args)).
 
 -spec apply(atom(), atom(), [term()]) -> term() | exception().
 apply(Module, Function, Args) when is_atom(Function), is_list(Args) ->
-    ?APPLY_SAFELY(erlang:apply(Module, Function, Args)).
+    ?SAFELY(erlang:apply(Module, Function, Args)).
 -endif.
 
 -spec apply_and_log(fun((...) -> A), [term()], map()) -> A | exception().

test/safely_SUITE.erl

@@ -1,5 +1,6 @@
 -module(safely_SUITE).
 -compile([export_all, nowarn_export_all]).
+-include("safely.hrl").
 -include_lib("eunit/include/eunit.hrl").
 
 all() ->
@@ -12,29 +13,30 @@ all() ->
 handles_errors_similar_to_catch(_) ->
     {SafeRes, CatchRes} =
         %% These two must be on the same line for the stacktraces to be equal.
-        {safely:apply(lists, min, [[]]),(catch apply(lists, min, [[]]))},
+        {?SAFELY(lists:min([])), catch lists:min([])},
 
     {exception, #{class := error, reason := function_clause, stacktrace := SafeST}} = SafeRes,
     {'EXIT', {function_clause, CatchST}} = CatchRes,
 
     true = (hd(CatchST) == hd(SafeST)),
 
-    {safely,apply,3,[{file,_},{line,_}]} = hd(tl(SafeST)), % this is extra in SafeStackTrace
+    % {safely,apply,3,[{file,_},{line,_}]} = hd(tl(SafeST)), % this is extra in SafeStackTrace
+    {lists,min,[[]],[{file,_},{line,_}]} = hd(SafeST), % this is extra in SafeStackTrace
 
-    true = (tl(CatchST) == tl(tl(SafeST))).
+    true = (tl(CatchST) == tl(SafeST)).
 
 handles_exits_similar_to_errors(_) ->
     ExitF = fun() -> exit(i_quit) end,
-    {exception, #{class := exit, reason := i_quit, stacktrace := _S}} = safely:apply(ExitF,[]),
+    {exception, #{class := exit, reason := i_quit, stacktrace := _S}} = ?SAFELY(ExitF()),
     {'EXIT', i_quit} = (catch apply(ExitF,[])),
     ok.
 
 handles_throws_unlike_catch(_) ->
     ThrowF = fun() -> throw(up) end,
-    {exception, #{class := throw, reason := up}} = safely:apply(ThrowF,[]),
+    {exception, #{class := throw, reason := up}} = ?SAFELY(ThrowF()),
     up = (catch apply(ThrowF,[])),
     ok.
 
 handles_success_like_catch(_) ->
-    1 = safely:apply(lists, min, [[1,2,3]]),
-    1 = (catch apply(lists, min, [[1,2,3]])).
+    1 = ?SAFELY(lists:min([1,2,3])),
+    1 = (catch lists:min([1,2,3])).