@spec caller() :: {module(), function(), arity :: non_neg_integer()} | :undefined

Returns the module/function/arity of the calling function.

If the calling function cannot be determined, returns :undefined. This can happen with BIFs in particular.

@spec disable_trace(trace_flag()) :: true

Turns off the provided trace_flag for the current process.

See the third parameter of :erlang.trace/3/ for a list of flags and their effects. Note that the :cpu_timestamp and :tracer flags are not supported in this function.

Always returns true.

@spec disable_trace(pid(), trace_flag()) :: true

Turns off the provided trace_flag for the specified pid.

See the third parameter of :erlang.trace/3/ for a list of flags and their effects. Note that the :cpu_timestamp and :tracer flags are not supported in this function.

Always returns true.

@spec display(value :: any()) ::
  {module(), function(), arity :: non_neg_integer()} | :undefined

Displays the given value on stdout for debugging purposes.

Always returns true.

@spec enable_trace(trace_flag()) :: true

Turns on the provided trace_flag for the current process.

See the third parameter of :erlang.trace/3/ for a list of flags and their effects. Note that the :cpu_timestamp and :tracer flags are not supported in this function.

Always returns true.

@spec enable_trace(pid(), trace_flag()) :: non_neg_integer()

Turns on the provided trace_flag for the specified pid.

See the third parameter of :erlang.trace/3/ for a list of flags and their effects. Note that the :cpu_timestamp and :tracer flags are not supported in this function.

Always returns true.

@spec exception_trace() :: true

Works as return_trace/0, generating an extra exception_from message on exceptions.

Causes a return_from trace message to be sent upon return from the current function. Plus, if the traced function exits because of an exception, an exception_from trace message is generated, whether or not the exception is caught.

If the process trace flag silent is active, the return_from and exception_from trace messages are inhibited.

Always returns true.

Warning: If the traced function is tail-recursive, this match specification function destroys that property. Hence, if a match specification executing this function is used on a perpetual server process, t can only be active for a limited period of time, or the emulator will eventually use all memory in the host machine and crash. If this match specification function is inhibited using process trace flag silent, tail-recursiveness still remains.

@spec get_seq_token() :: seq_token() | []

Retreives the (opaque) value of the trace token for the current process.

If the current process is not being traced, returns [].

Acts identically to :seq_trace.get_token/0. The docs say that the return value can be passed back into :seq_trace.set_token/1. However, in a tracing match spec context, there is no equivalent (set_seq_token/2 works, but there's no set_seq_token/1). So I am unsure what this can be used for.

For more information, consult :seq_trace.get_token/0 docs.

@spec get_tcw() :: trace_control_word when trace_control_word: non_neg_integer()

Returns the value of the current node's trace control word.

Identical to calling :erlang.system_info/1 with the argument :trace_control_word.

The trace control word is a 32-bit unsigned integer intended for generic trace control. The trace control word can be tested and set both from within trace match specifications and with BIFs.

@spec is_seq_trace() :: boolean()

Returns true if a sequential trace token is set for the current process, otherwise false.

@spec message(message | {message, false | message, true}) :: true when message: any()

Sets an additional message appended to the trace message sent.

One can only set one additional message in the body. Later calls replace the appended message.

Always returns true.

As a special case, {message, false} disables sending of trace messages ('call' and 'return_to') for this function call, just like if the match specification had not matched. This can be useful if only the side effects of the match spec clause's body part are desired.

Another special case is {message, true}, which sets the default behavior, as if the function had no match specification; trace message is sent with no extra information (if no other calls to message are placed before {message, true}, it is in fact a "noop").

@spec process_dump() :: true

Returns some textual information about the current process as a binary.

@spec return_trace() :: true

Causes a return_from trace message to be sent upon return from the current function.

If the process trace flag silent is active, the return_from trace message is inhibited.

Always returns true.

Warning:

If the traced function is tail-recursive, this match specification function destroys that property. Hence, if a match specification executing this function is used on a perpetual server process, it can only be active for a limited period of time, or the emulator will eventually use all memory in the host machine and crash. If this match specification function is inhibited using process trace flag silent, tail-recursiveness still remains.

@spec set_seq_token(seq_token_component(), seq_token_value()) :: true | charlist()

Sets a label, serial number, or flag token to value for sequential tracing.

Acts like :seq_trace.set_token/2, except returns true on success, and 'EXIT' on error or bad argument.

Note that this function cannot be used to exclude message passing from the trace, since that is normally accomplished by passing [] into :seq_trace.set_token/1 (however there is no set_seq_token/1 allowed in match specs).

Note that the values set here cannot be introspected in a match spec tracing context (get_seq_token/0 returns an opaque representation of the current trace token, but there's no get_seq_token/1 to inspect individual values).

For more information, consult :seq_trace.set_token/2 docs.

@spec set_tcw(trace_control_word) :: trace_control_word
when trace_control_word: non_neg_integer()

Sets the value of the current node's trace control word to trace_control_word.

Identical to calling :erlang.system_flag/2 with the arguments :trace_control_word and trace_control_word.

Returns the previous value of the node's trace control word.

@spec silent(mode :: boolean() | any()) :: any()

Changes the verbosity of the current process's messaging mode.

• If mode is true, supresses all trace messages.
• If mode is false, re-enables trace messages in future calls.
• If mode is anything else, the current mode remains active.

@spec trace(
  disable_flags :: [trace_flag() | tracer_trace_flag()],
  enable_flags :: [trace_flag() | tracer_trace_flag()]
) :: boolean()

@spec trace(
  disable_flags :: [trace_flag() | tracer_trace_flag()],
  enable_flags :: [trace_flag() | tracer_trace_flag()]
) :: boolean()

Atomically disables and enables a set of trace flags for the current process in one go.

Flags enabled in the enable_flags list will override duplicate flags in the disable_flags list.

See the third parameter of :erlang.trace/3/ for a list of flags and their effects. Note that the :cpu_timestamp flag is not supported in this function, however unlike the enable_trace/1 and disable_trace/1 functions, the :tracer flags are supported..

If no :tracer is specified, the same tracer as the process executing the match specification is used (not the meta tracer). If that process doesn't have tracer either, then trace flags are ignored. When using a tracer module, the module must be loaded before the match specification is executed. If it is not loaded, the match fails.

Returns true if any trace property was changed for the current process, otherwise false.

Atomically disables and enables a set of trace flags for the given pid in one go.

Flags enabled in the enable_flags list will override duplicate flags in the disable_flags list.

See the third parameter of :erlang.trace/3/ for a list of flags and their effects. Note that the :cpu_timestamp flag is not supported in this function, however unlike the enable_trace/1 and disable_trace/1 functions, the :tracer flags are supported..

If no :tracer is specified, the same tracer as the process executing the match specification is used (not the meta tracer). If that process doesn't have tracer either, then trace flags are ignored. When using a tracer module, the module must be loaded before the match specification is executed. If it is not loaded, the match fails.

Returns true if any trace property was changed for the given pid, otherwise false.