-spec change_pattern({Mod :: module(), Pattern}) -> ok
                        when
                            Pattern :: DetailLevel | TracePattern | EmptyTracePattern,
                            DetailLevel :: level(),
                            TracePattern :: [{[term()] | '_' | atom(), [term()], [term()]}],
                            EmptyTracePattern :: [].

change_pattern(Pattern) -> ok

Activates/deactivates tracing by changing the current trace pattern.

min detail level deactivates tracing of calls to et:trace_me/4,5

max detail level activates tracing of all calls to et:trace_me/4,5

integer(X) detail level activates tracing of all calls to et:trace_me/4,5 whose detail level argument is lesser than X.

An empty match spec deactivates tracing of calls to et:trace_me/4,5

Other match specs activates tracing of calls to et:trace_me/4,5 accordingly with erlang:trace_pattern/2.

-spec make_pattern({Mod :: module(), RawPattern}) -> {Mod :: module(), TracePattern}
                      when
                          RawPattern :: level(),
                          TracePattern :: [{[term()] | '_' | atom(), [term()], [term()]}].

make_pattern(RawPattern) -> TracePattern

Makes a trace pattern suitable to feed change_pattern/1

Min detail level deactivates tracing of calls to et:trace_me/4,5

Max detail level activates tracing of all calls to et:trace_me/4,5

integer(X) detail level activates tracing of all calls to et:trace_me/4,5 whose detail level argument is lesser than X.

See also erlang:trace_pattern/2 for more info about its match_spec()

-spec parse_event(Mod, ValidTraceData) -> boolean | {true, event()}
                     when
                         Mod :: module(),
                         ValidTraceData :: ErlangTraceData | event(),
                         ErlangTraceData ::
                             {trace, pid(), atom(), term()} |
                             {trace, pid(), atom(), term(), term()} |
                             {trace_ts, pid(), atom(), term(), TS :: {integer(), integer(), integer()}} |
                             {trace_ts,
                              pid(),
                              atom(),
                              term(),
                              term(),
                              TS :: {integer(), integer(), integer()}} |
                             {seq_trace, atom(), term()} |
                             {seq_trace, atom(), term(), TS :: {integer(), integer(), integer()}} |
                             {drop, integer()}.

parse_event(Mod, ValidTraceData) -> false | true | {true, Event}

Transforms trace data and makes an event record out of it.

See erlang:trace/3 for more info about the semantics of the trace data.

An event record consists of the following fields:

• detail_level - Noise has a high level as opposed to essentials.

• trace_ts - Time when the trace was generated. Same as event_ts if omitted in trace data.

• event_ts - Time when the event record was created.

• from - From actor, such as sender of a message.

• to - To actor, such as receiver of message.

• label - Label intended to provide a brief event summary.

• contents - All nitty gritty details of the event.

See et:trace_me/4and et:trace_me/5 for details.

Returns:

• {true, Event} - where Event is an #event{} record representing the trace data

• true - means that the trace data already is an event record and that it is valid as it is. No transformation is needed.

• false - means that the trace data is uninteresting and should be dropped