erl_tracer(3erl)

💅 erl_tracer — Erlang tracer behavior 💅

(erl_tracer(3erl), Erlang Module Definition)

---

✨ NAME ✨

erl_tracer — Erlang tracer behavior. That’s the whole name, bestie. 🫶

---

🦋 DESCRIPTION 🦋

Okay so this behavior module is literally the back end of the Erlang tracing system. The functions in this module get 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. That means the overhead from having tracing enabled is greatly effected by how much time gets spent in these functions. So bestie: do as little work as possible in these functions. Periodt. 💅

📝 Note 📝

All functions in this behavior must be implemented as NIFs. This limitation can be removed in future releases. An example tracer module NIF implementation is provided at the end of this page. 👀

🚨 Warning 🚨

Do not send messages or issue port commands to the Tracee in any of the callbacks. This is not allowed and can cause all sorts of strange behavior, including, but not limited to, infinite recursions. 😭 Do not do it. Nope. Not iconic. Not slay. Just chaos. 💀

---

🌈 DATA TYPES 🌈

🎀 trace_tag_call()

trace_tag_call() =
    call | return_to | return_from | exception_from

🎀 trace_tag_gc()

trace_tag_gc() =
    gc_minor_start | gc_minor_end | gc_major_start | gc_major_end

🎀 trace_tag_ports()

trace_tag_ports() =
    open | closed | link | unlink | getting_linked |
    getting_unlinked

🎀 trace_tag_procs()

trace_tag_procs() =
    spawn | spawned | exit | link | unlink | getting_linked |
    getting_unlinked | register | unregister

🎀 trace_tag_receive()

trace_tag_receive() = 'receive'

🎀 trace_tag_running_ports()

trace_tag_running_ports() =
    in | out | in_exiting | out_exiting | out_exited

🎀 trace_tag_running_procs()

trace_tag_running_procs() =
    in | out | in_exiting | out_exiting | out_exited

🎀 trace_tag_send()

trace_tag_send() = send | send_to_non_existing_process

🎀 trace_tag()

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

These are the different trace tags that the tracer is called with. Each trace tag is described in detail in Module:trace/5. iykyk 💖

🎀 tracee()

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

The process or port that the trace belongs to. Simple as that. 🦋

🎀 trace_opts()

trace_opts() =
    #{extra => term(),
      match_spec_result => term(),
      scheduler_id => integer() >= 0,
      timestamp =>
          timestamp | cpu_timestamp | monotonic | strict_monotonic}

The options for the tracee:

• timestamp — if set, the tracer has been requested to include a time stamp. ⏰
• extra — if set, the tracepoint has included additional data about the trace event. What the additional data is depends on which TraceTag has been triggered. The extra trace data corresponds to the fifth element in the trace tuples described in erlang:trace/3. 👀
• match_spec_result — if set, the tracer has been requested to include the output of a match specification that was run. 🎯
• scheduler_id — if set, the scheduler id is to be included by the tracer. 🧚

🎀 tracer_state()

tracer_state() = term()

The state specified when calling erlang:trace(PidPortSpec,true,[{tracer,Module,TracerState}]). The tracer state is an immutable value that is passed to erl_tracer callbacks and is to contain all the data that is needed to generate the trace event. Basically it’s the little bag of stuff your tracer carries around. 🎀

---

🎀 CALLBACK FUNCTIONS 🎀

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

• Module:enabled/3 — Mandatory 💖
• Module:trace/5 — Mandatory 💖
• Module:enabled_call/3 — Optional ✨
• Module:trace_call/5 — Optional ✨
• Module:enabled_garbage_collection/3 — Optional ✨
• Module:trace_garbage_collection/5 — Optional ✨
• Module:enabled_ports/3 — Optional ✨
• Module:trace_ports/5 — Optional ✨
• Module:enabled_procs/3 — Optional ✨
• Module:trace_procs/5 — Optional ✨
• Module:enabled_receive/3 — Optional ✨
• Module:trace_receive/5 — Optional ✨
• Module:enabled_running_ports/3 — Optional ✨
• Module:trace_running_ports/5 — Optional ✨
• Module:enabled_running_procs/3 — Optional ✨
• Module:trace_running_procs/5 — Optional ✨
• Module:enabled_send/3 — Optional ✨
• Module:trace_send/5 — Optional ✨

🌸 EXPORTS 🌸

okay so bestie, this is the callback lineup your tracer module can export. every signature, every type block, every little “if this is undefined, that gets called instead” is here. keep the names and args exactly as written — no cap 💅

---

💖 Module:enabled/3 — the earliest vibe check

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

Types:

TraceTag =  trace_tag() | trace_status
TracerState = term()
Tracee = tracee()
Result = trace | discard | remove

This callback is called whenever a tracepoint is triggered. It lets the tracer decide whether a trace is going to be generated or not. This check is made as early as possible to limit the amount of overhead associated with tracing. If trace is returned, the necessary trace data is created and the trace callback of the tracer is called. If discard is returned, this trace call is discarded and no call to trace is done.

trace_status is a special type of TraceTag, which is used to check if the tracer is still to be active. It is called in multiple scenarios, but most significantly it is used when tracing is started using this tracer. If remove is returned when the trace_status is checked, the tracer is removed from the tracee.

⚠️ This function can be called multiple times per tracepoint, so it is important that it is both fast and without side effects. fr fr, keep it snappy and pure.

---

🦋 Module:enabled_call/3

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

Types:

TraceTag =  trace_tag_call()
TracerState = term()
Tracee = tracee()
Result = trace | discard | remove

This callback is called whenever a tracepoint with trace flag call | return_to is triggered.

If enabled_call/3 is undefined, Module:enabled/3 is called instead.

---

🎀 Module:enabled_garbage_collection/3

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

Types:

TraceTag =  trace_tag_gc()
TracerState = term()
Tracee = tracee()
Result = trace | discard | remove

This callback is called whenever a tracepoint with trace flag garbage_collection is triggered.

If enabled_garbage_collection/3 is undefined, Module:enabled/3 is called instead.

---

🐚 Module:enabled_ports/3

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

Types:

TraceTag =  trace_tag_ports()
TracerState = term()
Tracee = tracee()
Result = trace | discard | remove

This callback is called whenever a tracepoint with trace flag ports is triggered.

If enabled_ports/3 is undefined, Module:enabled/3 is called instead.

---

🌟 Module:enabled_procs/3

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

Types:

TraceTag =  trace_tag_procs()
TracerState = term()
Tracee = tracee()
Result = trace | discard | remove

This callback is called whenever a tracepoint with trace flag procs is triggered.

If enabled_procs/3 is undefined, Module:enabled/3 is called instead.

---

🍓 Module:enabled_receive/3

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

Types:

TraceTag =  trace_tag_receive()
TracerState = term()
Tracee = tracee()
Result = trace | discard | remove

This callback is called whenever a tracepoint with trace flag 'receive' is triggered.

If enabled_receive/3 is undefined, Module:enabled/3 is called instead.

---

🌈 Module:enabled_running_ports/3

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

Types:

TraceTag =  trace_tag_running_ports()
TracerState = term()
Tracee = tracee()
Result = trace | discard | remove

This callback is called whenever a tracepoint with trace flag running_ports is triggered.

If enabled_running_ports/3 is undefined, Module:enabled/3 is called instead.

---

👑 Module:enabled_running_procs/3

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

Types:

TraceTag =  trace_tag_running_procs()
TracerState = term()
Tracee = tracee()
Result = trace | discard | remove

This callback is called whenever a tracepoint with trace flag running_procs | running is triggered.

If enabled_running_procs/3 is undefined, Module:enabled/3 is called instead.

---

💌 Module:enabled_send/3

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

Types:

TraceTag =  trace_tag_send()
TracerState = term()
Tracee = tracee()
Result = trace | discard | remove

This callback is called whenever a tracepoint with trace flag send is triggered.

If enabled_send/3 is undefined, Module:enabled/3 is called instead.

---

🔥 Module:trace/5 — the main character side-effect zone

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

Types:

TraceTag =  trace_tag()
TracerState = term()
Tracee = tracee()
TraceTerm = term()
Opts = trace_opts()
Result = ok

This callback is called when a tracepoint is triggered and the Module:enabled/3 callback returned trace. In it any side effects needed by the tracer are to be done. The tracepoint payload is located in the TraceTerm. The content of the TraceTerm depends on which TraceTag is triggered. TraceTerm corresponds to the fourth element in the trace tuples described in erlang:trace/3.

If the trace tuple has five elements, the fifth element will be sent as the extra value in the Opts maps.

---

🌊 Module:trace/5 with seq_trace

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

Types:

TracerState = term()
Label = term()
SeqTraceInfo = term()
Opts = trace_opts()
Result = ok

The TraceTag seq_trace is handled slightly differently. There is no Tracee for seq_trace, instead the Label associated with the seq_trace event is specified.

For more information on what Label and SeqTraceInfo can be, see seq_trace(3erl).

---

🧚 Module:trace_call/5

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

Types:

TraceTag =  trace_tag_call()
TracerState = term()
Tracee = tracee()
TraceTerm = term()
Opts = trace_opts()
Result = ok

This callback is called when a tracepoint is triggered and the Module:enabled_call/3 callback returned trace.

If trace_call/5 is undefined, Module:trace/5 is called instead.

---

🫶 Module:trace_garbage_collection/5

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

Types:

TraceTag =  trace_tag_gc()
TracerState = term()
Tracee = tracee()
TraceTerm = term()
Opts = trace_opts()
Result = ok

This callback is called when a tracepoint is triggered and the Module:enabled_garbage_collection/3 callback returned trace.

If trace_garbage_collection/5 is undefined, Module:trace/5 is called instead.

---

🎧 Module:trace_ports/5

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

Types:

TraceTag =  trace_tag()
TracerState = term()
Tracee = tracee()
TraceTerm = term()
Opts = trace_opts()
Result = ok

This callback is called when a tracepoint is triggered and the Module:enabled_ports/3 callback returned trace.

If trace_ports/5 is undefined, Module:trace/5 is called instead.

---

🪐 Module:trace_procs/5

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

Types:

TraceTag =  trace_tag()
TracerState = term()
Tracee = tracee()
TraceTerm = term()
Opts = trace_opts()
Result = ok

This callback is called when a tracepoint is triggered and the Module:enabled_procs/3 callback returned trace.

If trace_procs/5 is undefined, Module:trace/5 is called instead.

---

💌 Module:trace_receive/5

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

Types:

TraceTag =  trace_tag_receive()
TracerState = term()
Tracee = tracee()
TraceTerm = term()
Opts = trace_opts()
Result = ok

This callback is called when a tracepoint is triggered and the Module:enabled_receive/3 callback returned trace.

If trace_receive/5 is undefined, Module:trace/5 is called instead.

---

🌸 Module:trace_running_ports/5

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

Types:

TraceTag =  trace_tag_running_ports()
TracerState = term()
Tracee = tracee()
TraceTerm = term()
Opts = trace_opts()
Result = ok

This callback is called when a tracepoint is triggered and the Module:enabled_running_ports/3 callback returned trace.

If trace_running_ports/5 is undefined, Module:trace/5 is called instead.

---

⭐ Module:trace_running_procs/5

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

Types:

TraceTag =  trace_tag_running_procs()
TracerState = term()
Tracee = tracee()
TraceTerm = term()
Opts = trace_opts()
Result = ok

This callback is called when a tracepoint is triggered and the Module:enabled_running_procs/3 callback returned trace.

If trace_running_procs/5 is undefined, Module:trace/5 is called instead.

---

🦋 Module:trace_send/5

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

Types:

TraceTag =  trace_tag_send()
TracerState = term()
Tracee = tracee()
TraceTerm = term()
Opts = trace_opts()
Result = ok

This callback is called when a tracepoint is triggered and the Module:enabled_send/3 callback returned trace.

If trace_send/5 is undefined, Module:trace/5 is called instead.

✨ ERL TRACER MODULE EXAMPLE ✨

okay bestie, this is the glow-up 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. It's giving minimal queen energy, no cap.

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");
}

---

And that's the whole example, bestie — NIF backend, lightweight message tracer, the works. 💖

Source/version: Ericsson AB, erts 13.2.2.5. Date: not listed on the footer, so no fake date from me, fr fr. Page: erl_tracer(3erl). Byeeeee ✨🫶