Evitare l'output di enormi parametri binari quando si traccia con DBG

Question

Devo eseguire il debug di un codice che passa attorno a enormi binari nei parametri.

Per questo voglio usare una combinazione di dbg:tracer/0, dbg:p/2, dbg:tpl/3.

Ma se lo faccio tutti i binari vengono emessi ogni volta che per uno incasina l'output in modo che le informazioni importanti siano difficili da trovare.

Ciò che è ancora peggio, l'output di questi binari incasina i tempi del codice. Il che lo rende sufficientemente diverso da non poter riprodurre il comportamento che voglio dbg.

Voglio ancora vedere gli altri parametri ma non ho bisogno di vedere i binari (anche i binari abbreviati andrebbero bene).

Answer 1

Potresti voler usare qualcosa di simile:

-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).

Principalmente, sto usando una versione alternativa di dbg:tracer, che richiede due argomenti. Il primo è il tipo e potrebbe essere processi o porta (Vedi Doc per maggiori dettagli). Il secondo parametro è una funzione gestore di messaggi (in realtà una tupla contenente la funzione gestore e i dati iniziali del gestore), che verrà chiamata per ciascun messaggio di traccia.

Lì, puoi implementare la tua logica per troncare i binari più a lungo di un certo importo o di qualsiasi altra cosa devi fare.

Quindi, otterrai qualcosa di simile:

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}

Potresti voler troncare anche i valori di ritorno. Potresti anche guardare il modulo DBG per emulare la loro bella stampa (sfortunatamente, le funzioni di formattazione non vengono esportate lì).