Evitar la salida de enormes parámetros binarios al trazar con DBG

Question

Tengo que depurar algún código que pasa alrededor de grandes binarios en los parámetros.

Para esto quiero usar una combinación de dbg:tracer/0, dbg:p/2, dbg:tpl/3.

Pero si hago esto, todos los binarios se producen cada vez que para uno arruina la salida, por lo que la información importante es difícil de encontrar.

Lo que es aún peor, la salida de estos binarios arruina el momento del código. Lo que hace que se comporte lo suficientemente diferente para que no pueda reproducir el comportamiento que quiero dbg.

Todavía quiero ver los otros parámetros, pero no necesito ver los binarios (los binarios acortados también estarían bien).

Answer 1

Es posible que desee usar algo como esto:

-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, estoy usando una versión alternativa de dbg:tracer, que toma dos argumentos. El primero es el tipo y podría ser proceso o Puerto (Ver Doc para más detalles). El segundo parámetro es una función de controlador de mensajes (en realidad una tupla que contiene la función del controlador y los datos del controlador inicial), que se solicitará para cada mensaje de seguimiento.

Allí, puede implementar su lógica para truncar binarios más de una cierta cantidad o cualquier otra cosa que necesite hacer.

Entonces, obtendrás algo como:

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}

Es posible que desee truncar los valores de retorno también. También puede ver el módulo DBG para emular su bonita impresión (desafortunadamente, las funciones de formato no se exportan allí).