Test suite for recon_trace:calls

src/plugins/plugin_tracker.erl

@@ -0,0 +1,99 @@
+-module(plugin_tracker).
+-behaviour(recon_plugins).
+
+-export([filter_fun/5, start_value/2, is_plugin/0]).
+-import(recon_trace, [formatter/5, validate_opts/1, trace_to_io/2,
+                      format/1, extract_info/1, clear/0]).
+
+is_plugin() ->
+    true.
+
+filter_fun(TSpecs, Boundaries, IoServer, Formatter, _Opts) ->
+    generate_pattern_filter(Boundaries, TSpecs, IoServer, Formatter).
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%%% GENERATE PATTERN FILTER %%%
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+generate_pattern_filter(TSpecs, {Max, Time}, IoServer, Formatter) ->
+    clear(),
+    rate_tracer({Max, Time}, TSpecs, IoServer, Formatter);
+generate_pattern_filter(TSpecs, Max, IoServer, Formatter) ->
+    clear(),
+    count_tracer(Max, TSpecs, IoServer, Formatter).
+
+count_tracer(Max, _TSpecs, IoServer, Formatter) ->
+    fun
+        (_Trace, {_, _, N}) when N >= Max ->
+            IoServer ! rate_limit_tripped, clear();
+        (Trace, {TSpecs, Session,N}) when (N < Max) and is_tuple(Trace) ->
+            %%  Type = element(1, Trace),
+            handle_trace(Trace, N, TSpecs, IoServer, Formatter, Session)
+    end.
+
+rate_tracer({_Max, _Time}, _TSpecs, _IoServer, _Formatter) ->
+    io:format("Rate tracer is not supported for module: ~p~n", [?MODULE]).
+
+handle_trace(_, _, [], IoServer, _, _) ->
+     IoServer ! rate_limit_tripped, clear();
+handle_trace(Trace, N, [TSpec | TSpecRest] = TSpecs, IoServer, Formatter, Session) ->
+    Print = filter_call(Trace, TSpec, Session),
+    case Print of
+        reject -> {TSpecs, Session, N};
+        {print, Value, NewSession} ->
+            IoServer ! {print_value, Value},
+            {TSpecRest, NewSession, N+1};
+        {print, NewSession} ->
+            case Formatter(Trace) of
+                "" -> ok;
+                Formatted -> IoServer ! {msg, Formatted}                 
+            end,
+            {TSpecRest, NewSession, N+1};
+        _ -> {TSpecs, Session, N}
+    end.
+
+
+filter_call(TraceMsg, {M, F, PatternFun}, Session) ->
+    case extract_info(TraceMsg) of
+                    {call, _, _, [{TraceM,TraceF, Args}]} ->
+                        test_match(M, F, TraceM, TraceF, Args, PatternFun, Session);
+                    {call, _, _, [{TraceM, TraceF, Args}, _Msg]} ->
+                        test_match(M, F, TraceM, TraceF, Args, PatternFun, Session);
+                    %% if the trace is not a call, we just print it
+                    _ -> {print, Session}
+    end.
+
+test_match(M, F, TraceM, TraceF, Args, PatternFun, Session) ->
+    Match = 
+        case {M==TraceM, ((F=='_') or (F==TraceF)), PatternFun} of
+            {true, true, '_'} -> true;
+            {true, true, _} -> check;
+            _ -> false
+    end,
+
+    case Match of
+       true -> {print, Session};
+       false -> reject;
+       check ->
+           try erlang:apply(PatternFun, [Args, Session]) of
+               suppress -> reject;
+               print    -> {print, Session};
+               {print, Value} -> {print, Value, Session};
+               {print_session, NewSession} -> {print, maps:merge(Session, NewSession)};
+               {print_session, Value, NewSession} -> {print, Value, maps:merge(Session, NewSession)};
+               _   -> reject
+           catch
+               error:function_clause ->
+                   reject;
+               error:arity_no_match ->
+                   reject;
+               error:_E ->
+                   reject
+           end
+  end.
+
+%%% Start value for the dbg tracer process state
+start_value(_, {_, _}) ->
+  {0, undefined, 0};
+start_value(Specs, _Max) ->
+    {Specs, #{}, 0}.
+

src/recon_plugins.erl

@@ -0,0 +1,21 @@
+%%% @author <[email protected]>
+%%%  [https://flmath.github.io]
+%%% @doc
+%%% `recon_trace_use_dbg' is a module that allows API of recon use dbg module
+%%% The added value of this solution is more flexibility in the pattern matching
+%%% you can pattern match any structure you BEAM can put into function guard.
+-module(recon_plugins).
+%% API
+
+-type tspec() :: recon_trace_use_dbg:tspec().
+-type device() :: atom() | pid() | standard_io | standard_error | user.
+-type property() :: atom() | tuple().
+-type proplist() :: [property()].
+-type init() :: recon_trace_use_dbg:max_traces().
+-type matchspecs() :: recon_trace_use_dbg:matchspecs().
+
+-type filter_fun_type() :: fun((tspec() | [tspec()], init()) -> init()).
+
+-callback filter_fun(matchspecs(), init(), device(), pid(), proplist()) -> filter_fun_type().
+-callback is_plugin() -> boolean().
+-callback start_value(matchspecs(), init()) -> {matchspecs(), map(), init()}.

src/recon_trace.erl

@@ -187,6 +187,9 @@
 %% Internal exports
 -export([count_tracer/1, rate_tracer/2, formatter/5, format_trace_output/1, format_trace_output/2]).
 
+%% For use_dbg feature
+-export([trace_to_io/2, extract_info/1, validate_opts/1, fun_to_ms/1]).
+
 -type matchspec()    :: [{[term()] | '_', [term()], [term()]}].
 -type shellfun()     :: fun((_) -> term()).
 -type formatterfun() :: fun((_) -> iodata()).
@@ -228,6 +231,13 @@ clear() ->
     erlang:trace_pattern({'_','_','_'}, false, []), % unsets global
     maybe_kill(recon_trace_tracer),
     maybe_kill(recon_trace_formatter),
+
+    %% for recon_trace_use_dbg
+    maybe_kill(recon_trace_tracer),
+    catch unregister(recon_trace_tracer),
+    dbg:p(all,clear),
+    dbg:ctp('_'),
+    dbg:stop(),
     ok.
 
 %% @equiv calls({Mod, Fun, Args}, Max, [])
@@ -336,11 +346,18 @@ calls(TSpecs = [_|_], Max) ->
 
 calls({Mod, Fun, Args}, Max, Opts) ->
     calls([{Mod,Fun,Args}], Max, Opts);
-calls(TSpecs = [_|_], {Max, Time}, Opts) ->
+
+calls(TSpecs = [_|_], Boundaries, Opts) ->
+    case proplists:get_bool(use_dbg, Opts) of
+        true -> recon_trace_use_dbg:calls_dbg(TSpecs, Boundaries, Opts);
+        false -> spec_calls(TSpecs, Boundaries, Opts)
+    end.
+
+spec_calls(TSpecs = [_|_], {Max, Time}, Opts) ->
     Pid = setup(rate_tracer, [Max, Time],
                 validate_formatter(Opts), validate_io_server(Opts)),
     trace_calls(TSpecs, Pid, Opts);
-calls(TSpecs = [_|_], Max, Opts) ->
+spec_calls(TSpecs = [_|_], Max, Opts) ->
     Pid = setup(count_tracer, [Max],
                 validate_formatter(Opts), validate_io_server(Opts)),
     trace_calls(TSpecs, Pid, Opts).
@@ -486,7 +503,7 @@ validate_tspec(Mod, Fun, Args) when is_function(Args) ->
 validate_tspec(Mod, Fun, return_trace) ->
     validate_tspec(Mod, Fun, [{'_', [], [{return_trace}]}]);
 validate_tspec(Mod, Fun, Args) ->
-    BannedMods = ['_', ?MODULE, io, lists],
+    BannedMods = ['_', ?MODULE, io, lists, recon_trace_use_dbg],
     %% The banned mod check can be bypassed by using
     %% match specs if you really feel like being dumb.
     case {lists:member(Mod, BannedMods), Args} of
@@ -515,7 +532,12 @@ validate_io_server(Opts) ->
 %% Thanks Geoff Cant for the foundations for this.
 format(TraceMsg) ->
     {Type, Pid, {Hour,Min,Sec}, TraceInfo} = extract_info(TraceMsg),
-    {FormatStr, FormatArgs} = case {Type, TraceInfo} of
+    {FormatStr, FormatArgs} = trace_to_io(Type, TraceInfo),
+    io_lib:format("~n~p:~p:~9.6.0f ~p " ++ FormatStr ++ "~n",
+                  [Hour, Min, Sec, Pid] ++ FormatArgs).
+
+trace_to_io(Type, TraceInfo) ->
+    case {Type, TraceInfo} of
         %% {trace, Pid, 'receive', Msg}
         {'receive', [Msg]} ->
             {"< ~p", [Msg]};
@@ -590,9 +612,7 @@ format(TraceMsg) ->
              [HeapSize + OldHeapSize + MbufSize]};
         _ ->
             {"unknown trace type ~p -- ~p", [Type, TraceInfo]}
-    end,
-    io_lib:format("~n~p:~p:~9.6.0f ~p " ++ FormatStr ++ "~n",
-                  [Hour, Min, Sec, Pid] ++ FormatArgs).
+    end.
 
 extract_info(TraceMsg) ->
     case tuple_to_list(TraceMsg) of