[erlang-questions] Simple wrapper around dbg?

[Attila Rajmund Nohl]

Hello!

I can trace a function call with specific arguments with a command like this:

dbg:tpl(foo, bar, dbg:fun2ms(fun([baz,_]) -> return_trace(),
exception_trace() end)).

However, it's a long to type, I'd like to have a wrapper around it.
The naive solution doesn't even compile:

-module(d).

-export([mfa/3]).

mfa(M, F, A) ->
dbg:tpl(M, F, dbg:fun2ms(fun(Args) when Args==A -> return_trace(),
exception_trace() end)).

because there are no return_trace() and exception_trace() functions in
the module. Even if it'd compile, I couldn't call it like this:

d:mfa(foo, bar, [baz, _]).

because the _ variable is not bound. Is there a simple workaround or
shall I start to read up on parse_transforms?
_______________________________________________
erlang-questions mailing list
erlang-q...@erlang.org
http://erlang.org/mailman/listinfo/erlang-questions

[Philip Clarke]

Hi Attila,

This might not be answering the exact question you are asking, but have you tried using the built in trace patterns ?

They can save you a lot of typing.  The build in trace patterns are documented in the dbg man page (under the tpl/0 function).

For example, you can use 

dbg:tpl(foo, bar, x) 

as an alias for 

dbg:tpl(foo, bar, x, [{'_', [], [{exception_trace}]}]).

Best regards

Philip

[Kenneth Lundin]

The parse transform is already written for you, see http://www.erlang.org/documentation/doc-5.2/lib/stdlib-1.11.0/doc/html/ms_transform.html

/Kenneth , Erlang/OTP Ericsson

[Garrett Smith]

On Tue, Nov 6, 2012 at 8:33 AM, Attila Rajmund Nohl
<attila...@gmail.com> wrote:
> Hello!
>
> I can trace a function call with specific arguments with a command like this:
>
> dbg:tpl(foo, bar, dbg:fun2ms(fun([baz,_]) -> return_trace(),
> exception_trace() end)).
>
> However, it's a long to type, I'd like to have a wrapper around it.

It's very limited, but for basic tracing (modules and functions with
sensible defaults) I use e2_debug:

https://github.com/gar1t/e2/blob/master/src/e2_debug.erl

Garrett

[Dmitry Klionsky]

Hi!

have a look at there links:
http://www.snookles.com/erlang/user_default.erl
https://github.com/eproxus/erlang_user_utilities/blob/master/user_default.erl

--
Best regards,
Dmitry Klionsky

[Patrik Nyblom]

On 11/06/2012 03:33 PM, Attila Rajmund Nohl wrote:

Hello!

I can trace a function call with specific arguments with a command like this:

dbg:tpl(foo, bar, dbg:fun2ms(fun([baz,_]) -> return_trace(),
exception_trace() end)).

However, it's a long to type, I'd like to have a wrapper around it.
The naive solution doesn't even compile:

-module(d).

-export([mfa/3]).

mfa(M, F, A) ->
    dbg:tpl(M, F, dbg:fun2ms(fun(Args) when Args==A -> return_trace(),
exception_trace() end)).

As described in the docs ( http://www.erlang.org/doc/man/dbg.html#fun2ms-1), you'll need to include ms_transform.hrl if calling dbg:fun2ms inside a module, so this:
---------------
-module(d).
-include_lib("stdlib/include/ms_transform.hrl").

-export([mfa/3]).

mfa(M, F, A) ->
    dbg:tpl(M, F, dbg:fun2ms(fun(Args) when Args==A -> return_trace(),
exception_trace() end)).

----------------
compiles and works to a certain extent.

because there are no return_trace() and exception_trace() functions in
the module. Even if it'd compile, I couldn't call it like this:

d:mfa(foo, bar, [baz, _]).

This is more tricky, you cannot send unbound variables to a function - it has little to do with dbg:fun2ms. Either you have to write your own parse_transform, which cannot be used from the shell, or you could use the match_spec syntax for the variables in the argument list and skip fun2ms altogether...
Look at this in the shell:
1> dbg:fun2ms(fun([baz,A,_])  -> return__trace(),exception_trace() end).
[{[baz,'_'],[],[{return_trace},{exception_trace}]}]
The argument list is translated so that anonymous variables become the atom '_' and named variables become '$n', where n is an integer > 0. You can write your function as:

mfa(M, F, A) ->
    dbg:tpl(M, F, [{A,[],[{return_trace},{exception_trace}]}]).

and call it as:
d:mfa(foo,bar,[baz,'_']).

In that case you will not need the parse_transform.

BTW, you can remove return_trace, exception_trace includes return_trace.

Cheers,
/Patrik