pan

• File TC|IP|Wrap - directs output
  TC atom() - send output to regular file. TC is used to construct the directory name - default is timestamp()
  IP ip|{ip, CallBack} - send trace messages to the host over IP
  CallBack atom() - name of callback module Wrap {wrap, TC}|{wrap, TC, Cnt}|{wrap, TC, Cnt, Siz} - send output to wrap log files
  Cnt integer() - number of wrap files - default is 8
  Siz integer() - max size of wrap files (bytes) - default is 128k
  
• Nodes axd|all|Node|[Node] - nodes to run trace on - default is axd
  axd - expands to all nodes matching "axd301@cp*"
  all - expands to all known nodes
  Node atom() - erlang node name
  
• Procs all|Proc|[Proc] - processes to trace - default is all
  all - all processes
  new - all processes that are created after the start of the trace
  existing - all processes that existes at the start of the trace
  Proc RegName|Pid
  RegName atom() - registered name
  Pid pid()
• Flags Flag|[Flag] - see erlang:trace/3 (R9) (R8) (R7) for description of flags - default is [procs, set_on_spawn]
  Flag can also be the aliases;
  dbg = [set_on_spawn,timestamp,call]
  gc = [set_on_spawn,timestamp,call,garbage_collection]
  proc = [set_on_spawn,timestamp,call,garbage_collection,running, send,'receive'] perf = [set_on_spawn,timestamp,call,garbage_collection,running,procs]
  prof = [set_on_spawn,timestamp,call,garbage_collection,running,procs, return_to,arity] all = [set_on_spawn,timestamp,call,garbage_collection,running,procs, return_to,arity,send,'receive']
• TPs [TP] - specifies which functions are seen in a call trace
  • TP - Mre|{Mre, MS}|M|{M}|{M, MS}|{M,F}|{M,F,MS}| {M,F,A}|{M,F,A,MS}
  • Mre string() - Mre is a regexp that is matched against all module names
  • M atom() - module
  • F atom() - function
  • A integer() - arity
  • MS list() - match specification, see OTP erts doc
    the match spec aliases
    stack -> {'_',[],[{message,{process_dump}}]}
    and
    return -> {'_',[],[{return_trace}]};
    can be used to get stack and return value info, respectively.
  the atom local can be appended to all TP tuples to activate tracing on non-exported functions. By default, the traing only applies to global (i.e. exported) functions.

• Examples:
  • perf trace on entire system (all procs)
    pan:start(perftrc,axd,'',perf).
  • call trace on some modules in half call processes
    ("^cc" expands to all all exported functions in modules with names that begin with "cc")
    pan:start(unitrc,axd,mdispServer,call,["^cc",uniDecode,uniEncode]).
  • profiling trace on half call processes (pretty slow)
    pan:start(proftrc,axd,mdispServer,prof,[{'_', local}]).
  • debug (call,send,receive) trace on all exported functions in modules starting with "cc"
    pan:start(dbgtrc,axd,mdispServer,dbg,["^cc"]).
  • call trace on SAAL signalling
    pan:start(sigtrc,'','','',[{saalEncode,aal_data_req},{saalDecode,decode}]).
  • call trace on erlang:now/0 with process info via the ip port
    pan:start(ip,all,all,call,{erlang,now,[stack]}).
  • as above but with callback
    pan:start({ip, cb_stack},'','','',{erlang,now,[stack]}).
  • call trace on all exported functions in the calendar module with return value; pan:start(ip,'','','',{calendar,[return]}).

• File string() - log file name
• OutFile string() - output file name - default is the screen
• Filter {cb, M}|Term - calls the function M:go([Msg, Line, Out, State]) -> NewState or scans for messages containing Term
  M atom() - callback function module name
  Term term() - scan filter term
  Msg {Tag, ProcI, Data, Timestamp} - trace message
  Tag atom() - trace message tag (see below)
  ProcI {Pid, Info} - process info
  Pid pid()
  Info RegName|InitCall
  RegName atom() - registered name
  InitCall MFA - initial call
  MFA {Module, Function, Arity}
  Data term() - extra trace info (see below)
  Timestamp timestamp()|no_time
  Out fd() - file descriptor of output file
  State term() - callback functions state

  
        Tag                           Data
        'receive',                    Message
        call,                         {M,F,A}
        exit,                         Reason
        return_to,                    {M,F,A}
        spawn,                        Pid2
        link,                         Pid2
        unlink,                       Pid2
        getting_linked,               Pid2
        in,                           {M,F,A}
        out,                          {M,F,A}
        gc_start,                     Info
        gc_end,                       Info
        send,                         {Pid2, Msg}
        send_to_non_existing_process, {Msg, Pid2}
        return_from,                  {{M,F,A}, ReturnValue}
  

• FirstMsg integer() - sequence number of first message to process
• LastMsg integer() - sequence number of last message to process

• Examples:
  • call the callback function cb_cnt:go/1 once foreach message in the trc file
    pan:scan("/home/etxmacr/dmp/axd301@cp1-19-010302-132820.trc",'',{cb,cb_cnt}).
  • print all messages that contain the atom get_cp pan:scan("/tmp/pan/unitrc/axd301@cp1-1-010315-090446.trc",'', get_cp).

• File string() - file name of the test case (typically /tmp/pan/<TC>)
• OutFile string() - output file name - default is screen

• File string() - file name of the test case (typically /tmp/pan/<TC>)
• Proc string()|tuple() - display profiling for the process Proc. Proc can be an atom (a registered name), an initial call ({M,F,A}) or, if thee are more that one process with the same initial call the tuple {{M,F,A}, N}, where the integer N is an arbitrary index.
• Stack list() - display profiling at Stack, where Stack is a list of {M, F, A} tuples. if Stack is the empty atom '' the most cpu expensive stack is shown.

• TPs list() - list of TP (trace patterns). see pan:start
• Nodes list() - list of erlang node names to trace on
• Procs list() - list of process names to trace on