NAME

erl_tracer - Erlang tracer behavior.

DESCRIPTION

This behavior module implements the back end of the Erlang tracing system. The functions in this module are called whenever a trace probe is triggered. Both the enabled and trace functions are called in the context of the entity that triggered the trace probe. This means that the overhead by having the tracing enabled is greatly effected by how much time is spent in these functions. So, do as little work as possible in these functions.

DATA TYPES

trace_tag_call() = 


    call | return_to | return_from | exception_from

trace_tag_gc() = 


    gc_minor_start | gc_minor_end | gc_major_start | gc_major_end

trace_tag_ports() = 


    open | closed | link | unlink | getting_linked |


    getting_unlinked

trace_tag_procs() = 


    spawn | spawned | exit | link | unlink | getting_linked |


    getting_unlinked | register | unregister

trace_tag_receive() = 'receive'

trace_tag_running_ports() = 


    in | out | in_exiting | out_exiting | out_exited

trace_tag_running_procs() = 


    in | out | in_exiting | out_exiting | out_exited

trace_tag_send() = send | send_to_non_existing_process

trace_tag() = 


    trace_tag_send() |


    trace_tag_receive() |


    trace_tag_call() |


    trace_tag_procs() |


    trace_tag_ports() |


    trace_tag_running_procs() |


    trace_tag_running_ports() |


    trace_tag_gc()

tracee() = port() | pid() | undefined

trace_opts() = 


    #{extra => term(),


      match_spec_result => term(),


      scheduler_id => integer() >= 0,


      timestamp =>


          timestamp | cpu_timestamp | monotonic | strict_monotonic}

tracer_state() = term()

CALLBACK FUNCTIONS

The following functions are to be exported from an erl_tracer callback module:

EXPORTS

Module:enabled(TraceTag, TracerState, Tracee) -> Result

Module:enabled_call(TraceTag, TracerState, Tracee) -> Result

Module:enabled_garbage_collection(TraceTag, TracerState, Tracee) -> Result

Module:enabled_ports(TraceTag, TracerState, Tracee) -> Result

Module:enabled_procs(TraceTag, TracerState, Tracee) -> Result

Module:enabled_receive(TraceTag, TracerState, Tracee) -> Result

Module:enabled_running_ports(TraceTag, TracerState, Tracee) -> Result

Module:enabled_running_procs(TraceTag, TracerState, Tracee) -> Result

Module:enabled_send(TraceTag, TracerState, Tracee) -> Result

Module:trace(TraceTag, TracerState, Tracee, TraceTerm, Opts) -> Result

Module:trace(seq_trace, TracerState, Label, SeqTraceInfo, Opts) -> Result

Module:trace_call(TraceTag, TracerState, Tracee, TraceTerm, Opts) -> Result

Module:trace_garbage_collection(TraceTag, TracerState, Tracee, TraceTerm, Opts) -> Result

Module:trace_ports(TraceTag, TracerState, Tracee, TraceTerm, Opts) -> Result

Module:trace_procs(TraceTag, TracerState, Tracee, TraceTerm, Opts) -> Result

Module:trace_receive(TraceTag, TracerState, Tracee, TraceTerm, Opts) -> Result

Module:trace_running_ports(TraceTag, TracerState, Tracee, TraceTerm, Opts) -> Result

Module:trace_running_procs(TraceTag, TracerState, Tracee, TraceTerm, Opts) -> Result

Module:trace_send(TraceTag, TracerState, Tracee, TraceTerm, Opts) -> Result

ERL TRACER MODULE EXAMPLE

In this example, a tracer module with a NIF back end sends a message for each send trace tag containing only the sender and receiver. Using this tracer module, a much more lightweight message tracer is used, which only records who sent messages to who.

The following is an example session using it on Linux:

$ gcc -I erts-8.0/include/ -fPIC -shared -o erl_msg_tracer.so erl_msg_tracer.c
$ erl
Erlang/OTP 19 [DEVELOPMENT] [erts-8.0] [source-ed2b56b] [64-bit] [smp:8:8] [async-threads:10] [hipe] [kernel-poll:false]
Eshell V8.0  (abort with ^G)
1> c(erl_msg_tracer), erl_msg_tracer:load().
ok
2> Tracer = spawn(fun F() -> receive M -> io:format("~p~n",[M]), F() end end).
<0.37.0>
3> erlang:trace(new, true, [send,{tracer, erl_msg_tracer, Tracer}]).
0
{trace,<0.39.0>,<0.27.0>}
4> {ok, D} = file:open("/tmp/tmp.data",[write]).
{trace,#Port<0.486>,<0.40.0>}
{trace,<0.40.0>,<0.21.0>}
{trace,#Port<0.487>,<0.4.0>}
{trace,#Port<0.488>,<0.4.0>}
{trace,#Port<0.489>,<0.4.0>}
{trace,#Port<0.490>,<0.4.0>}
{ok,<0.40.0>}
{trace,<0.41.0>,<0.27.0>}
5>

erl_msg_tracer.erl:

-module(erl_msg_tracer).
-export([enabled/3, trace/5, load/0]).
load() ->


    erlang:load_nif("erl_msg_tracer", []).
enabled(_, _, _) ->


    error.
trace(_, _, _, _, _) ->


    error.

erl_msg_tracer.c:

#include <erl_nif.h>
/* NIF interface declarations */
static int load(ErlNifEnv* env, void** priv_data, ERL_NIF_TERM load_info);
static int upgrade(ErlNifEnv* env, void** priv_data, void** old_priv_data, ERL_NIF_TERM load_info);
static void unload(ErlNifEnv* env, void* priv_data);
/* The NIFs: */
static ERL_NIF_TERM enabled(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]);
static ERL_NIF_TERM trace(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]);
static ErlNifFunc nif_funcs[] = {


    {"enabled", 3, enabled},


    {"trace", 5, trace}
};
ERL_NIF_INIT(erl_msg_tracer, nif_funcs, load, NULL, upgrade, unload)
static int load(ErlNifEnv* env, void** priv_data, ERL_NIF_TERM load_info)
{


    *priv_data = NULL;


    return 0;
}
static void unload(ErlNifEnv* env, void* priv_data)
{
}
static int upgrade(ErlNifEnv* env, void** priv_data, void** old_priv_data,
		   ERL_NIF_TERM load_info)
{


    if (*old_priv_data != NULL || *priv_data != NULL) {
	return -1; /* Don't know how to do that */


    }


    if (load(env, priv_data, load_info)) {
	return -1;


    }


    return 0;
}
/*


 * argv[0]: TraceTag


 * argv[1]: TracerState


 * argv[2]: Tracee


 */
static ERL_NIF_TERM enabled(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
{


    ErlNifPid to_pid;


    if (enif_get_local_pid(env, argv[1], &to_pid))


        if (!enif_is_process_alive(env, &to_pid))


            if (enif_is_identical(enif_make_atom(env, "trace_status"), argv[0]))


                /* tracer is dead so we should remove this tracepoint */


                return enif_make_atom(env, "remove");


            else


                return enif_make_atom(env, "discard");


    /* Only generate trace for when tracer != tracee */


    if (enif_is_identical(argv[1], argv[2]))


        return enif_make_atom(env, "discard");


    /* Only trigger trace messages on 'send' */


    if (enif_is_identical(enif_make_atom(env, "send"), argv[0]))


        return enif_make_atom(env, "trace");


    /* Have to answer trace_status */


    if (enif_is_identical(enif_make_atom(env, "trace_status"), argv[0]))


        return enif_make_atom(env, "trace");


    return enif_make_atom(env, "discard");
}
/*


 * argv[0]: TraceTag, should only be 'send'


 * argv[1]: TracerState, process to send {Tracee, Recipient} to


 * argv[2]: Tracee


 * argv[3]: Message


 * argv[4]: Options, map containing Recipient


 */
static ERL_NIF_TERM trace(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
{


    ErlNifPid to_pid;


    ERL_NIF_TERM recipient, msg;


    if (enif_get_local_pid(env, argv[1], &to_pid)) {


      if (enif_get_map_value(env, argv[4], enif_make_atom(env, "extra"), &recipient)) {


        msg = enif_make_tuple3(env, enif_make_atom(env, "trace"), argv[2], recipient);


        enif_send(env, &to_pid, NULL, msg);


      }


    }


    return enif_make_atom(env, "ok");
}