Module trace_mpath

anypid() = pid() | comm:mypid()

erlang_timestamp() = 
    {MegaSecs :: non_neg_integer(),
     Secs :: 0..999999,
     MicroSecs :: 0..999999}

filter_fun() = fun((trace_event()) -> boolean())

gc_mpath_msg() = 
    {'$gen_component',
     trace_mpath,
     passed_state(),
     Source :: anypid(),
     Dest :: anypid(),
     comm:message()}

info_event() = 
    {log_info, time(), trace_id(), pidinfo(), comm:message()}

logger() = 
    io_format |
    {log_collector, comm:mypid()} |
    {proto_sched, comm:mypid()}

msg_map_fun() = 
    fun((comm:message(),
         Source :: pid() | comm:mypid(),
         Dest :: pid() | comm:mypid()) ->
            comm:message())

options() = 
    [{logger, logger() | comm:mypid()} |
     {map_fun, msg_map_fun()} |
     {filter_fun, filter_fun()}]

passed_state() = passed_state1() | {trace_id(), logger()}

passed_state1() = 
    {trace_id(), logger(), msg_map_fun(), filter_fun()}

pidinfo() = 
    {comm:mypid(),
     {pid_groups:groupname(), pid_groups:pidname()} |
     no_pid_name |
     non_local_pid_name_unknown}

recv_event() = 
    {log_recv,
     time(),
     trace_id(),
     Source :: pidinfo(),
     Dest :: pidinfo(),
     comm:message()}

send_event() = 
    {log_send,
     time(),
     trace_id(),
     Source :: pidinfo(),
     Dest :: pidinfo(),
     comm:message(),
     local | global}

state() = [{trace_id(), trace()}]

time() = erlang_timestamp() | non_neg_integer()

trace() = [trace_event()]

trace_event() = send_event() | info_event() | recv_event()

trace_id() = atom()

start_gen_component(Module :: module(),
                    Handler :: gen_component:handler(),
                    Args :: term(),
                    Options :: [gen_component:option()],
                    Self :: pid()) ->
                       no_return() | ok

start() -> ok

start(TraceId :: trace_id() | passed_state()) -> ok

start(TraceId :: trace_id(),
      Options :: logger() | comm:mypid() | options()) ->
         ok

stop() -> ok

infected() -> boolean()

clear_infection() -> ok

restore_infection() -> ok

get_trace() -> trace()

get_trace(TraceId :: trace_id()) -> trace()

get_trace(TraceId :: trace_id(), Option :: cleanup | none) ->
             trace()

get_trace_raw(TraceId :: trace_id()) -> trace()

get_trace_raw(TraceId :: trace_id(), Option :: cleanup | none) ->
                 trace()

cleanup() -> ok

cleanup(TraceId :: trace_id()) -> ok

thread_yield() -> ok

send_histogram(Trace :: trace()) -> list()

time_delta(Trace :: trace()) -> trace()

to_texfile(Trace :: trace(), Filename :: file:name()) ->
              ok | {error, file:posix() | badarg | terminated}

to_texfile(Trace :: trace(),
           Filename :: file:name(),
           ScaleX :: pos_integer()) ->
              ok | {error, file:posix() | badarg | terminated}

to_texfile_no_time(Trace :: trace(), Filename :: file:name()) ->
                      ok |
                      {error, file:posix() | badarg | terminated}

to_texfile_no_time(Trace :: trace(),
                   Filename :: file:name(),
                   ScaleX :: pos_integer()) ->
                      ok |
                      {error, file:posix() | badarg | terminated}

get_msg_tag(Msg :: comm:message()) -> atom() | {atom(), atom()}

epidemic_reply_msg(PState :: passed_state(),
                   FromPid :: anypid(),
                   ToPid :: anypid(),
                   Msg :: comm:message()) ->
                      gc_mpath_msg()

log_send(PState :: passed_state(),
         FromPid :: anypid(),
         ToPid :: anypid(),
         Msg :: comm:message(),
         LocalOrGlobal :: local | global | local_after,
         SendOptions :: comm:send_options()) ->
            DeliverAlsoDirectly :: boolean()

log_info(FromPid :: anypid(), Info :: comm:message()) -> ok

log_info(PState :: passed_state(),
         FromPid :: anypid(),
         Info :: comm:message()) ->
            ok

log_recv(PState :: passed_state(),
         FromPid :: anypid(),
         ToPid :: anypid(),
         Msg :: comm:message()) ->
            ok

normalize_pidinfo(Pid :: anypid() | pidinfo()) -> pidinfo()

start_link(ServiceGroup :: pid_groups:groupname()) -> {ok, pid()}

init(Arg :: any()) -> state()

on(Msg :: trace_event() | comm:message(), State :: state()) ->
      state()