Éviter la production d'énormes params binaires lors du traçage avec dbg

Question

Je dois déboguer un code qui passe autour des binaires énormes dans les params.

Pour cela, je veux utiliser une combinaison de dbg:tracer/0, dbg:p/2, dbg:tpl/3.

Mais si je fais cela tous les binaires sont émis chaque fois que pour un bousille la sortie si l'information importante est difficile à trouver.

Ce qui est encore pire, la sortie de ces binaires bousille le calendrier du code. Ce qui en fait se comportent suffisamment différents pour que je ne peux pas reproduire le comportement que je veux dbg.

Je veux encore voir les autres params mais ne pas besoin de voir les binaires (binaires raccourcies seraient également ok).

Answer 1

Vous pouvez utiliser quelque chose comme ceci:

-module(test).

-compile(export_all).

foo(_LongBinary, _OtherParam) ->
    ok.

test() ->
    dbg:tracer(process, {
         fun({trace, Pid, call, {M,F,A}}, _) ->
             NewA = lists:map(fun(<<Reduced:5/binary, _/binary>>) ->
                          Reduced;
                         (Else) ->
                          Else
                      end, A),
             erlang:display({Pid, "->", M, F, NewA});       
            ({trace, Pid, return_from, {M,F,A}, R}, _) ->
             erlang:display({Pid, "<-", M, F, A, R})        
         end, unused}),
    dbg:p(all,c),
    dbg:tpl(test, foo, x).

Principalement, j'utilise une version alternative de dbg:tracer, qui prend deux arguments. Le premier est le type et pourrait être processus ou port (voir doc pour plus de détails). Le second paramètre est une fonction de gestionnaire de messages (en fait un tuple contenant la fonction de gestionnaire et les données de gestionnaire initial), qui sera appelé pour chaque message de trace.

, vous pouvez mettre en œuvre votre logique pour les binaires truncate plus d'un certain montant ou tout ce que vous devez faire.

Alors, vous obtiendrez quelque chose comme:

1> test:test().                               
{ok,[{matched,nonode@nohost,1},{saved,x}]}
2> test:foo(<<"aa">>,b).                      
ok
3> {<0.45.0>,"->",test,foo,[<<2 bytes>>,b]}
{<0.45.0>,"<-",test,foo,2,ok}
4> test:foo(<<"aaaaaaa">>,b).
ok
5> {<0.45.0>,"->",test,foo,[<<5 bytes>>,b]}
{<0.45.0>,"<-",test,foo,2,ok}
6> test:foo(<<"aaaaaaasdaaaaaaaaa">>,b).
ok
7> {<0.45.0>,"->",test,foo,[<<5 bytes>>,b]}
{<0.45.0>,"<-",test,foo,2,ok}

Vous pouvez tronquer les valeurs de retour aussi bien. Vous pouvez aussi regarder le module dbg d'imiter leur jolie impression (malheureusement, fonctions de formatage ne sont pas exportées là-bas).