Rename module and functions to be shorter and more generic. Remove quickcheck tests. Wire into the non-sasl error_handler, but don't wire into handle_info and handle_call functions since those should not be logs.

5 files changed, 35 insertions, 183 deletions

diff --git a/src/rabbit_error_logger.erl b/src/rabbit_error_logger.erl
index e921925e..53c0e608 100644
--- a/src/rabbit_error_logger.erl
+++ b/src/rabbit_error_logger.erl
@@ -89,7 +89,7 @@ publish1(RoutingKey, Format, Data, LogExch) ->
     Timestamp = rabbit_misc:now_ms() div 1000,
 
     %% TODO: is 'Data' ever in crash report format? I think not, but check...
-    Args = [rabbit_trunc_term:truncate_log_event(A) || A <- Data],
+    Args = [truncate:log_event(A) || A <- Data],
     {ok, _DeliveredQPids} =
         rabbit_basic:publish(LogExch, RoutingKey,
                              #'P_basic'{content_type = <<"text/plain">>,
diff --git a/src/rabbit_error_logger_file_h.erl b/src/rabbit_error_logger_file_h.erl
index 27bfa9de..2f66f98f 100644
--- a/src/rabbit_error_logger_file_h.erl
+++ b/src/rabbit_error_logger_file_h.erl
@@ -92,20 +92,21 @@ handle_event(Event = {error, _, {emulator, _, ["Discarding message" ++ _]}},
     case get(discarding_message_seen) of
         true      -> {ok, State};
         undefined -> put(discarding_message_seen, true),
-                     error_logger_file_h:handle_event(Event, State)
+                     error_logger_file_h:handle_event(
+                       truncate:log_event(Event), State)
     end;
 %% Clear this state if we log anything else (but not a progress report).
 handle_event(Event = {info_msg, _, _}, State) ->
     erase(discarding_message_seen),
-    error_logger_file_h:handle_event(Event, State);
+    error_logger_file_h:handle_event(truncate:log_event(Event), State);
 handle_event(Event, State) ->
-    error_logger_file_h:handle_event(Event, State).
+    error_logger_file_h:handle_event(truncate:log_event(Event), State).
 
-handle_info(Event, State) ->
-    error_logger_file_h:handle_info(Event, State).
+handle_info(Info, State) ->
+    error_logger_file_h:handle_info(Info, State).
 
-handle_call(Event, State) ->
-    error_logger_file_h:handle_call(Event, State).
+handle_call(Call, State) ->
+    error_logger_file_h:handle_call(Call, State).
 
 terminate(Reason, State) ->
     error_logger_file_h:terminate(Reason, State).
diff --git a/src/rabbit_sasl_report_file_h.erl b/src/rabbit_sasl_report_file_h.erl
index 1b950c23..efdef3f6 100644
--- a/src/rabbit_sasl_report_file_h.erl
+++ b/src/rabbit_sasl_report_file_h.erl
@@ -66,16 +66,13 @@ init_file({File, Type}) ->
     end.
 
 handle_event(Event, State) ->
-    Event2 = rabbit_trunc_term:truncate_log_event(Event),
-    sasl_report_file_h:handle_event(Event2, State).
+    sasl_report_file_h:handle_event(truncate:log_event(Event), State).
 
-handle_info(Event, State) ->
-    Event2 = rabbit_trunc_term:truncate_log_event(Event),
-    sasl_report_file_h:handle_info(Event2, State).
+handle_info(Info, State) ->
+    sasl_report_file_h:handle_info(Info, State).
 
-handle_call(Event, State) ->
-    Event2 = rabbit_trunc_term:truncate_log_event(Event),
-    sasl_report_file_h:handle_call(Event2, State).
+handle_call(Call, State) ->
+    sasl_report_file_h:handle_call(Call, State).
 
 terminate(Reason, State) ->
     sasl_report_file_h:terminate(Reason, State).
diff --git a/src/rabbit_trunc_term_tests.erl b/src/rabbit_trunc_term_tests.erl
deleted file mode 100644
index 6a3a7169..00000000
--- a/src/rabbit_trunc_term_tests.erl
+++ /dev/null
@@ -1,146 +0,0 @@
-%% The contents of this file are subject to the Mozilla Public License
-%% Version 1.1 (the "License"); you may not use this file except in
-%% compliance with the License. You may obtain a copy of the License
-%% at http://www.mozilla.org/MPL/
-%%
-%% Software distributed under the License is distributed on an "AS IS"
-%% basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
-%% the License for the specific language governing rights and
-%% limitations under the License.
-%%
-%% The Original Code is RabbitMQ.
-%%
-%% The Initial Developer of the Original Code is GoPivotal, Inc.
-%% Copyright (c) 2007-2014 GoPivotal, Inc.  All rights reserved.
-%%
-
--module(rabbit_trunc_term_tests).
-
--ifdef(use_proper_qc).
-
--export([prop_trunc_any_term/0]).
--include_lib("proper/include/proper.hrl").
-
-prop_trunc_any_term() ->
-    ?FORALL({GenAny, MaxSz}, {gen_top_level(50), gen_max_len()},
-            begin
-                try
-                    SzInitial = erts_debug:size(GenAny),
-                    Shrunk  = rabbit_trunc_term:shrink_term(GenAny, MaxSz),
-                    SzShrunk = erts_debug:size(Shrunk),
-                    ?WHENFAIL(begin
-                                  io:format("MaxLen: ~p~n", [MaxSz]),
-                                  io:format("SizeOfThing: ~p~n",
-                                            [size_of_thing(GenAny)]),
-                                  io:format("Input-Size: ~p~n", [SzInitial]),
-                                  io:format("Shrunk-Size: ~p~n", [SzShrunk]),
-                                  io:format("Input: ~p~n", [GenAny]),
-                                  io:format("Output: ~p~n", [Shrunk])
-                              end,
-                              case size_of_thing(GenAny) > MaxSz of
-                                  true  -> SzShrunk < SzInitial;
-                                  false -> Shrunk =:= GenAny
-                              end)
-                catch
-                    _:Err ->
-                        io:format("\nException: ~p~n",
-                                  [{Err, erlang:get_stacktrace()}]),
-                        io:format("Input: ~p~n", [GenAny]),
-                        io:format("Max-Size: ~p~n", [MaxSz]),
-                        false
-                end
-            end).
-
-size_of_thing(Thing) when is_bitstring(Thing) -> byte_size(Thing);
-size_of_thing(Thing) when is_binary(Thing)    -> size(Thing);
-size_of_thing(Thing) when is_list(Thing)      -> length(Thing);
-size_of_thing(Thing) when is_tuple(Thing)     -> size(Thing);
-size_of_thing(Thing)                          -> error({cannot_size, Thing}).
-
-%% Generates a printable string
-gen_print_str() ->
-    ?LET(Xs, list(char()), [X || X <- Xs, io_lib:printable_list([X]), X /= $~, X < 255]).
-
-gen_print_bin() ->
-    ?LET(Xs, gen_print_str(), list_to_binary(Xs)).
-
-gen_top_level(MaxDepth) ->
-    oneof([gen_print_str(),
-           gen_iolist(1000),
-           binary(),
-           gen_bitstring(),
-           gen_print_bin()] ++
-           [?LAZY(list(gen_any(MaxDepth - 1))) || MaxDepth /= 0] ++
-           [?LAZY(gen_tuple(gen_any(MaxDepth - 1))) || MaxDepth /= 0]).
-
-gen_any(MaxDepth) ->
-    oneof([largeint(),
-           gen_atom(),
-           gen_quoted_atom(),
-           nat(),
-           %real(),
-           gen_print_str(),
-           gen_iolist(1000),
-           binary(),
-           gen_bitstring(),
-           gen_print_bin(),
-           gen_pid(),
-           gen_port(),
-           gen_ref(),
-           gen_fun()] ++
-           [?LAZY(list(gen_any(MaxDepth - 1))) || MaxDepth > 1] ++
-           [?LAZY(gen_tuple(gen_any(MaxDepth - 1))) || MaxDepth > 1]).
-
-gen_iolist(0) ->
-    [];
-gen_iolist(Depth) ->
-    list(oneof([gen_char(),
-                gen_print_str(),
-                gen_print_bin(),
-                gen_iolist(Depth-1)])).
-
-gen_atom() ->
-    elements([abc, def, ghi]).
-
-gen_quoted_atom() ->
-    elements(['noname@nonode', '@localhost', '10gen']).
-
-gen_bitstring() ->
-    ?LET(XS, binary(), <<XS/binary, 1:7>>).
-
-gen_tuple(Gen) ->
-    ?LET(Xs, list(Gen), list_to_tuple(Xs)).
-
-gen_max_len() -> %% 3..N
-    ?LET(Xs, int(), 3 + abs(Xs)).
-
-gen_pid() ->
-    ?LAZY(spawn(fun() -> ok end)).
-
-gen_port() ->
-    ?LAZY(begin
-              Port = erlang:open_port({spawn, "true"}, []),
-              catch(erlang:port_close(Port)),
-              Port
-          end).
-
-gen_ref() ->
-    ?LAZY(make_ref()).
-
-gen_fun() ->
-    ?LAZY(fun() -> ok end).
-
-gen_char() ->
-    oneof(lists:seq($A, $z)).
-
--else.
-
--export([prop_disabled/0]).
-
-prop_disabled() ->
-    exit({compiled_without_proper,
-          "PropEr was not present during compilation of the test module. "
-          "Hence all tests are disabled."}).
-
--endif.
-
diff --git a/src/rabbit_trunc_term.erl b/src/truncate.erl
index cd2dfe3b..7828a986 100644
--- a/src/rabbit_trunc_term.erl
+++ b/src/truncate.erl
@@ -14,37 +14,37 @@
 %% Copyright (c) 2007-2014 GoPivotal, Inc.  All rights reserved.
 %%
 
--module(rabbit_trunc_term).
+-module(truncate).
 
--export([truncate_log_event/1]).
+-export([log_event/1]).
 %% exported for testing
--export([shrink_term/1, shrink_term/2]).
+-export([term/1, term/2]).
 
-truncate_log_event({Type, GL, {Pid, Format, Args}})
+log_event({Type, GL, {Pid, Format, Args}})
   when Type =:= error orelse
        Type =:= info_msg orelse
        Type =:= warning_msg ->
-    {Type, GL, {Pid, Format, [shrink_term(T) || T <- Args]}};
-truncate_log_event({Type, GL, {Pid, ReportType, Report}})
+    {Type, GL, {Pid, Format, [term(T) || T <- Args]}};
+log_event({Type, GL, {Pid, ReportType, Report}})
   when Type =:= error_report orelse
        Type =:= info_report orelse
        Type =:= warning_report ->
     Report2 = case ReportType of
-                  crash_report -> [[{K, shrink_term(V)} || {K, V} <- R] ||
+                  crash_report -> [[{K, term(V)} || {K, V} <- R] ||
                                       R <- Report];
-                  _            -> [{K, shrink_term(V)} || {K, V} <- Report]
+                  _            -> [{K, term(V)} || {K, V} <- Report]
               end,
     {Type, GL, {Pid, ReportType, Report2}};
-truncate_log_event(Event) ->
+log_event(Event) ->
     Event.
 
-shrink_term(T) -> shrink_term(T, 10).
+term(T) -> term(T, 10).
 
 %% TODO: avoid copying
 %% TODO: can we get away with using binary:part/3 (OTP vsn requirements)?
 %% TODO: reconsider depth limit handling
-shrink_term(T, 0) -> T;
-shrink_term(T, N) when is_binary(T) andalso size(T) > N ->
+term(T, 0) -> T;
+term(T, N) when is_binary(T) andalso size(T) > N ->
     Suffix = N - 3,
     Len = case is_bitstring(T) of
               true  -> byte_size(T);
@@ -55,30 +55,30 @@ shrink_term(T, N) when is_binary(T) andalso size(T) > N ->
                            <<Head/binary, <<"...">>/binary>>;
         _               -> T
     end;
-shrink_term([A|B], N) when not is_list(B) ->
-    shrink_term([A,B], N);
-shrink_term(T, N) when is_list(T) ->
+term([A|B], N) when not is_list(B) ->
+    term([A,B], N);
+term(T, N) when is_list(T) ->
     IsPrintable = io_lib:printable_list(T),
     Len = length(T),
     case {Len > N, IsPrintable} of
         {true, true}
           when N > 3   -> lists:append(lists:sublist(T, resize(N-3)), "...");
-        {true, false}  -> lists:append([shrink_term(E, resize(N-1, Len)) ||
+        {true, false}  -> lists:append([term(E, resize(N-1, Len)) ||
                                            E <- lists:sublist(T, resize(N-1))],
                                        ['...']);
-        {false, false} -> [shrink_term(E, resize(N-1, Len)) || E <- T];
+        {false, false} -> [term(E, resize(N-1, Len)) || E <- T];
         _              -> T
     end;
-shrink_term(T, N) when is_tuple(T) ->
+term(T, N) when is_tuple(T) ->
     case tuple_size(T) > N of
         true  -> list_to_tuple(
-                   lists:append([shrink_term(E, N-1) ||
+                   lists:append([term(E, N-1) ||
                                     E <- lists:sublist(tuple_to_list(T), N-1)],
                                 ['...']));
-        false -> list_to_tuple([shrink_term(E, N-1) ||
+        false -> list_to_tuple([term(E, N-1) ||
                                    E <- tuple_to_list(T)])
     end;
-shrink_term(T, _) -> T.
+term(T, _) -> T.
 
 resize(N) -> resize(N, 1).