Have a completely separate counter for content size vs structural size.

5 files changed, 47 insertions, 32 deletions

diff --git a/include/rabbit.hrl b/include/rabbit.hrl
index 3d2301ef..8f836a0e 100644
--- a/include/rabbit.hrl
+++ b/include/rabbit.hrl
@@ -119,11 +119,12 @@
 %% wrapping the message body).
 -define(MAX_MSG_SIZE, 2147383648).
 
-%% Maximum size of any individual bit of a term to be logged. Feeds
-%% into truncate:log_event/2.
--define(LOG_TRUNC_SIZE, 100).
-
-%% Amount to decrease size every time we descend while truncating
--define(LOG_TRUNC_DECR, 5).
+%% 1) Maximum size of printable lists and binaries.
+%% 2) Maximum size of any structural term.
+%% 3) Amount to decrease 1) every time we descend while truncating.
+%% 4) Amount to decrease 2) every time we descend while truncating.
+%%
+%% Whole thing feeds into truncate:log_event/2.
+-define(LOG_TRUNC, {1000, 100, 50, 5}).
 
 -define(store_proc_name(N), rabbit_misc:store_proc_name(?MODULE, N)).
diff --git a/src/rabbit_error_logger.erl b/src/rabbit_error_logger.erl
index 73f843c3..717e7de0 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 = [truncate:term(A, ?LOG_TRUNC_SIZE, ?LOG_TRUNC_DECR) || A <- Data],
+    Args = [truncate:term(A, ?LOG_TRUNC) || 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 9c5dd448..16ab6d3a 100644
--- a/src/rabbit_error_logger_file_h.erl
+++ b/src/rabbit_error_logger_file_h.erl
@@ -116,4 +116,4 @@ code_change(OldVsn, State, Extra) ->
 
 %%----------------------------------------------------------------------
 
-t(Term) -> truncate:log_event(Term, ?LOG_TRUNC_SIZE, ?LOG_TRUNC_DECR).
+t(Term) -> truncate:log_event(Term, ?LOG_TRUNC).
diff --git a/src/rabbit_sasl_report_file_h.erl b/src/rabbit_sasl_report_file_h.erl
index 0006141f..4881210d 100644
--- a/src/rabbit_sasl_report_file_h.erl
+++ b/src/rabbit_sasl_report_file_h.erl
@@ -68,7 +68,7 @@ init_file({File, Type}) ->
 
 handle_event(Event, State) ->
     sasl_report_file_h:handle_event(
-      truncate:log_event(Event, ?LOG_TRUNC_SIZE, ?LOG_TRUNC_DECR), State).
+      truncate:log_event(Event, ?LOG_TRUNC), State).
 
 handle_info(Info, State) ->
     sasl_report_file_h:handle_info(Info, State).
diff --git a/src/truncate.erl b/src/truncate.erl
index 6b361462..7113cfa4 100644
--- a/src/truncate.erl
+++ b/src/truncate.erl
@@ -18,56 +18,69 @@
 
 -define(ELLIPSIS_LENGTH, 3).
 
--export([log_event/3, term/3]).
+-record(params, {content, struct, content_dec, struct_dec}).
+
+-export([log_event/2, term/2]).
 %% exported for testing
 -export([test/0]).
 
-log_event({Type, GL, {Pid, Format, Args}}, Size, Decr)
+log_event({Type, GL, {Pid, Format, Args}}, Params)
   when Type =:= error orelse
        Type =:= info_msg orelse
        Type =:= warning_msg ->
-    {Type, GL, {Pid, Format, [term(T, Size, Decr) || T <- Args]}};
-log_event({Type, GL, {Pid, ReportType, Report}}, Size, Decr)
+    {Type, GL, {Pid, Format, [term(T, Params) || T <- Args]}};
+log_event({Type, GL, {Pid, ReportType, Report}}, Params)
   when Type =:= error_report orelse
        Type =:= info_report orelse
        Type =:= warning_report ->
-    {Type, GL, {Pid, ReportType, report(Report, Size, Decr)}};
-log_event(Event, _Size, _Decr) ->
+    {Type, GL, {Pid, ReportType, report(Report, Params)}};
+log_event(Event, _Params) ->
     Event.
 
-report([[Thing]], Size, Decr) -> report([Thing], Size, Decr);
-report(List, Size, Decr)      -> [case Item of
-                                      {K, V} -> {K, term(V, Size, Decr)};
-                                      _      -> term(Item, Size, Decr)
+report([[Thing]], Params) -> report([Thing], Params);
+report(List, Params)      -> [case Item of
+                                      {K, V} -> {K, term(V, Params)};
+                                      _      -> term(Item, Params)
                                   end || Item <- List].
 
-term(Bin, N, _D) when (is_binary(Bin) orelse is_bitstring(Bin))
-                      andalso size(Bin) > N - ?ELLIPSIS_LENGTH ->
+term(Thing, {Content, Struct, ContentDec, StructDec}) ->
+    term(Thing, #params{content     = Content,
+                        struct     = Struct,
+                        content_dec = ContentDec,
+                        struct_dec = StructDec});
+
+term(Bin, #params{content = N}) when (is_binary(Bin) orelse is_bitstring(Bin))
+                                     andalso size(Bin) > N - ?ELLIPSIS_LENGTH ->
     Suffix = without_ellipsis(N),
     <<Head:Suffix/binary, _/bitstring>> = Bin,
     <<Head/binary, <<"...">>/binary>>;
-term(L, N, D) when is_list(L) ->
+term(L, #params{struct = N} = Params) when is_list(L) ->
     case io_lib:printable_list(L) of
         true  -> N2 = without_ellipsis(N),
                  case length(L) > N2 of
                      true  -> string:left(L, N2) ++ "...";
                      false -> L
                  end;
-        false -> shrink_list(L, N, D)
+        false -> shrink_list(L, Params)
     end;
-term(T, N, D) when is_tuple(T) ->
-    list_to_tuple(shrink_list(tuple_to_list(T), N, D));
-term(T, _, _) ->
+term(T, Params) when is_tuple(T) ->
+    list_to_tuple(shrink_list(tuple_to_list(T), Params));
+term(T, _) ->
     T.
 
 without_ellipsis(N) -> erlang:max(N - ?ELLIPSIS_LENGTH, 0).
 
-shrink_list(_, N, _) when N =< 0 ->
+shrink_list(_, #params{struct = N}) when N =< 0 ->
     ['...'];
-shrink_list([], _N, _D) ->
+shrink_list([], _) ->
     [];
-shrink_list([H|T], N, D) ->
-    [term(H, N - D, D) | term(T, N - 1, D)].
+shrink_list([H|T], #params{content     = Content,
+                           struct      = Struct,
+                           content_dec = ContentDec,
+                           struct_dec  = StructDec} = Params) ->
+    [term(H, Params#params{content = Content - ContentDec,
+                           struct  = Struct  - StructDec})
+     | term(T, Params#params{struct = Struct - 1})].
 
 %%----------------------------------------------------------------------------
 
@@ -77,7 +90,7 @@ test() ->
     ok.
 
 test_short_examples_exactly() ->
-    F = fun (Term, Exp) -> Exp = term(Term, 10, 5) end,
+    F = fun (Term, Exp) -> Exp = term(Term, {10, 10, 5, 5}) end,
     F([], []),
     F("h", "h"),
     F("hello world", "hello w..."),
@@ -94,7 +107,8 @@ test_short_examples_exactly() ->
     ok.
 
 test_large_examples_for_size() ->
-    Shrink = fun(Term) -> term(Term, 100, 5) end, %% Real world values
+    %% Real world values
+    Shrink = fun(Term) -> term(Term, {1000, 100, 50, 5}) end,
     TestSize = fun(Term) ->
                        true = 5000000 < size(term_to_binary(Term)),
                        true = 500000 > size(term_to_binary(Shrink(Term)))