Current section
Files
Jump to
Current section
Files
src/redbug_dtop.erl
%%%-------------------------------------------------------------------
%%% File : redbug_dtop.erl
%%% Created : 5 Sep 2005
%%% Created : 16 Dec 2003
%%% Created : 5 Dec 2003 by Mats Cronqvist <qthmacr@duna283>
%%% Created : 8 Dec 2003 by Mats Cronqvist <qthmacr@duna283>
%%% Created : 18 Oct 2005 by Mats Cronqvist <locmacr@mwlx084>
%%% Description : top-like client for beam
%%%-------------------------------------------------------------------
%% @private
-module(redbug_dtop).
-author('Mats Cronqvist').
-export([start/0,
stop/0,
sort/1,
max_prcs/1]).
%%%---------------------------
%%% API
%% workaround for get_stacktrace confusion in OTP 21
-ifdef(OTP_RELEASE). %% this implies 21 or higher
-define(EXCEPTION(Class, Reason, StackToken), Class:Reason:StackToken).
-define(GET_STACK(StackToken), StackToken).
-else.
-define(EXCEPTION(Class, Reason, _), Class:Reason).
-define(GET_STACK(_), erlang:get_stacktrace()).
-endif.
start() ->
case whereis(redbug_dtop) of
undefined -> spawn(fun blocking_start/0);
_ -> exit(already_started)
end.
blocking_start() ->
try loop(init())
catch ?EXCEPTION(C, R, S) -> erlang:display({C, R, ?GET_STACK(S)})
end.
stop() -> exit(whereis(redbug_dtop), kill).
sort(Col) ->
case lists:member(Col, sort_criteria()) of
true -> redbug_dtop ! {config, sort, Col};
false -> {unknown_sort_criteria, sort_criteria()}
end.
max_prcs(MaxPrcs) ->
case is_integer(MaxPrcs) of
true -> redbug_dtop ! {config, max_prcs, MaxPrcs};
false -> {bad_limit, not_integer}
end.
sort_criteria() -> [cpu, mem, msgq].
%%%---------------------------
-record(ld,
{fd = standard_io,
sort = cpu,
tick = 2000,
lines = 19,
strategy = strategy(),
constants,
cache = [],
now = erlang:timestamp(),
prcs = 6,
max_prcs = 3000}).
-record(data,
{sys, prc, net, mnesia}).
%%%---------------------------
init() ->
register(redbug_dtop, self()),
LD0 = #ld{},
LD1 = LD0#ld{constants = constants(LD0)},
erlang:send_after(LD1#ld.tick, self(), timeout),
LD1#ld{cache = get_data(LD1)}.
loop(LD) ->
receive
timeout ->
erlang:send_after(LD#ld.tick, self(), timeout),
loop(printer(LD));
{config, Key, Val} ->
loop(config(LD, Key, Val))
end.
config(LD, sort, Val) ->
LD#ld{sort = Val};
config(LD, max_prcs, Val) ->
LD#ld{max_prcs = Val}.
printer(LD) ->
Data = get_data(LD),
TS = erlang:timestamp(),
DT = delta_time(TS, LD#ld.now),
print(LD, differ(DT, LD#ld.cache, Data)),
LD#ld{now = TS, cache = Data}.
get_data(LD) ->
#data{sys = get_sys_data(LD),
prc = get_prc_data(LD),
net = get_net_data(),
mnesia = get_mnesia_data()}.
print(LD, #data{sys = SysData, prc = PrcData}) ->
print_del(LD#ld.fd),
print_sys(LD#ld.fd, SysData),
io:fwrite(LD#ld.fd, "~n", []),
print_tags(LD#ld.fd),
print_prcs(LD, PrcData, SysData).
print_sys(FD, Sys) ->
io:fwrite(FD, "~s~n", [sys_str(Sys)]),
io:fwrite(FD, memf(), memi(Sys)).
memf() ->
"memory: proc~8s, atom~8s, bin~8s, code~8s, ets~8s~n".
memi(Sys) ->
try [human(pull_sys(T, Sys)) || T <- [processes, atom, binary, code, ets]]
catch _:_ -> ["", "", "", "", ""]
end.
sys_str(Sys) ->
{_, Time} = calendar:now_to_local_time(pull_sys(now, Sys)),
H = pad(element(1, Time), 2, $0, left),
M = pad(element(2, Time), 2, $0, left),
S = pad(element(3, Time), 2, $0, left),
Node = node(),
MEMbeam = human(pull_sys(beam_vsz, Sys)),
MEM = human(pull_sys(total, Sys)),
CPUbeam = to_list(100*(pull_sys_d(beam_user, Sys) + pull_sys_d(beam_kernel, Sys))),
CPU = to_list(100*(pull_sys_d(user, Sys)+pull_sys_d(kernel, Sys))),
Prcs = human(pull_sys(prcs, Sys)),
RunQ = human(pull_sys(run_queue, Sys)),
SYS = lists:sublist(lists:append(["size: " , MEM,
"(" , MEMbeam,
"), cpu%: " , CPUbeam,
"(" , CPU,
"), procs: ", Prcs,
", runq: " , RunQ,
", ", H, ":", M, ":", S]), 79),
pad(Node, 79-length(SYS), $ , right)++SYS.
pad(Item, Len, Pad, LeftRight) ->
Str = to_list(Item),
case length(Str) of
L when L =:= Len -> Str;
L when L<Len -> pad(Str, L, Len, Pad, LeftRight);
_ -> lists:sublist(Str, Len)
end.
pad(Str, L, Len, Pad, LeftRight) ->
case LeftRight of
left -> lists:duplicate(Len-L, Pad)++Str;
right-> Str++lists:duplicate(Len-L, Pad)
end.
print_del(FD) ->
io:fwrite(FD, "~s~n", [lists:duplicate(79, $-)]).
format() -> "~-14s ~-28s ~-17s~7s~7s~4s~n".
tags() -> ["pid", "name", "current", "msgq", "mem", "cpu"].
print_tags(FD) ->
io:fwrite(FD, format(), tags()).
print_prcs(LD, PrcData, SysData) ->
Prcs = complete_info(toplist(LD, PrcData), SysData),
lists:foreach(fun(Prc) -> print_prc(LD, Prc) end, pad_lines(LD, Prcs)).
pad_lines(#ld{lines = Lines}, Prcs) ->
case Lines < length(Prcs) of
true -> lists:sublist(Prcs, Lines);
false-> Prcs++lists:duplicate(Lines-length(Prcs), [])
end.
print_prc(#ld{fd = FD}, Prc) ->
try
io:fwrite(FD,
format(),
[pidf(to_list(pull_prc(pid, Prc))),
funf(reg(Prc)),
funf(pull_prc(current_function, Prc)),
human(pull_prc(message_queue_len, Prc)),
human(pull_prc(memory, Prc)),
to_list(pull_prc(cpu, Prc))])
catch
_:_ -> io:fwrite(FD, "~n", [])
end.
reg(Prc) ->
case pull_prc(registered_name, Prc) of
[] -> pull_prc(initial_call, Prc);
Val -> Val
end.
pidf(Pid) ->
[_, A, B] = string:tokens(Pid, "."),
lists:append(["<0.", A, ".", B]).
funf({M, F, A}) -> to_list(M)++":"++to_list(F)++"/"++to_list(A);
funf(Term) -> io_lib:fwrite("~p", [Term]).
complete_info(PrcData, SysData) ->
CpuPerRed = cpu_per_red(SysData),
lists:map(fun(P) -> complete(P, CpuPerRed) end, PrcData).
cpu_per_red(SysData) ->
case pull_sys_d(reductions, SysData) of
0 -> 0;
Reds -> 100*cpu(SysData)/Reds
end.
cpu(SysData) ->
case pull_sys_d(beam_user, SysData) + pull_sys_d(beam_kernel, SysData) of
C when C == +0.0 -> 1;
C -> C
end.
%%----------------------------------------------------
%% calculate rates
differ(DT, OldData, NewData) ->
#data{sys = diff(DT, OldData#data.sys, NewData#data.sys),
prc = diff(DT, index_prc(pid), OldData#data.prc, NewData#data.prc),
net = diff(DT, index_net(port), OldData#data.net, NewData#data.net),
mnesia = diff(DT, OldData#data.mnesia, NewData#data.mnesia)}.
%% diff 2 lists of tuples.
%% Select pairs of tuples where I:th element are identical
%% lists should be sorted on I:th element
diff(DT, I, [Old|_] = Olds, [New|_] = News) ->
Kold = element(I, Old),
Knew = element(I, New),
case {Kold =:= Knew, Kold < Knew} of
{true, _} -> [diff(DT, Old, New)|diff(DT, I, tl(Olds), tl(News))];
{false, true} -> diff(DT, I, tl(Olds), News);
{false, false} -> diff(DT, I, Olds, tl(News))
end;
diff(_, _, _, _) ->
[].
%% diff each element in 2 tuples
diff(DT, Old, New) when is_tuple(Old) andalso is_tuple(New) ->
list_to_tuple(ldiff(DT, tuple_to_list(Old), tuple_to_list(New))).
%% diff elementwise on 2 equally shaped lists
%% if the element is a number, diff === {NewNumber, (NewNumber-OldNumber)/DeltaTime}
%% else, diff === NewElement
ldiff(_, [], []) ->
[];
ldiff(DT, [Old|Olds], [New|News]) when is_number(Old) andalso is_number(New)->
[{New, df(DT, Old, New)}|ldiff(DT, Olds, News)];
ldiff(DT, [_|Olds], [New|News]) ->
[New|ldiff(DT, Olds, News)].
df(DT, X, Y) ->
try (Y-X)/DT
catch _:_ -> 0
end.
%%--------------------------------------------------------------------------
%% calculate process toplist
%% return [#prc{}], with length =< integer(Lines), sorted on atom(Sort)
toplist(#ld{lines = N, sort = Sort}, PrcData) ->
lists:sublist(lists:reverse(lists:sort(mk_toplist_le(Sort), PrcData)), N).
mk_toplist_le(Sort) ->
Pull = mk_pull(Sort),
fun(A, B) -> Pull(A) =< Pull(B) end.
mk_pull(cpu) -> fun(X) -> pull_prc_d(reductions, X) end;
mk_pull(msgq) -> fun(X) -> pull_prc(message_queue_len, X) end;
mk_pull(mem) -> fun(X) -> pull_prc(memory, X) end.
%%%-------------------------------------------------------------------
%% collects info about the OS and the Erlang system.
%% * emulator info
%% call the BIFs memory/0, statistics/1 and system_info/1
%% * OS info
%% if OS is Linux 2.6 or greater;
%% - read from /proc/stat, /proc/meminfo (and /proc/net/dev ?)
%% - read from /proc/self/stat (and /proc/self/statm ?)
%% else if OS is darwin
%% - run the ps command in a port
%% else
%% - return an empty list
%%
%%
-record(sys,
{now,
prcs, %% [count] erlang:system_info(process_count)
context_switches, %% [count/s] erlang:statistics(context_switches)
gcs, %% [count/s] erlang:statistics(garbage_collection)
gc_reclaimed, %% [byte/s] erlang:statistics(garbage_collection)
io_in, %% [byte/s] erlang:statistics(io)
io_out, %% [byte/s] erlang:statistics(io)
reductions, %% [count/s] erlang:statistics(reductions)
run_queue, %% [count] erlang:statistics(run_queue)
total, %% [byte] erlang:memory()
processes, %% [byte] erlang:memory()
processes_used, %% [byte] erlang:memory()
system, %% [byte] erlang:memory()
atom, %% [byte] erlang:memory()
atom_used, %% [byte] erlang:memory()
binary, %% [byte] erlang:memory()
code, %% [byte] erlang:memory()
ets, %% [byte] erlang:memory()
user, %% [frac] /proc/stat
nice, %% [frac] /proc/stat
kernel, %% [frac] /proc/stat
idle, %% [frac] /proc/stat
iowait, %% [frac] /proc/stat
ctxt, %% [frac] /proc/stat
beam_user, %% [frac] /proc/self/stat
beam_kernel, %% [frac] /proc/self/stat
beam_vsz, %% [byte] /proc/self/stat
beam_rss, %% [pages] /proc/self/stat
beam_minflt, %% [count/s] /proc/self/stat
beam_majflt, %% [count/s] /proc/self/stat
cores, %% [count] /proc/stat
total_ram}). %% [byte] /proc/meminfo
-record(sys_const, {total_ram, cores}).
-record(sys_os,
{user = 0,
nice = 0,
kernel = 0,
idle = 0,
iowait = 0,
beam_user = 0,
beam_sys = 0,
vsz = 0,
rss = 0,
minflt = 0,
majflt = 0
}).
pull_sys_d(reductions , Sys) -> maybe_el(2, Sys#sys.reductions);
pull_sys_d(beam_kernel, Sys) -> maybe_el(2, Sys#sys.beam_kernel);
pull_sys_d(beam_user , Sys) -> maybe_el(2, Sys#sys.beam_user);
pull_sys_d(kernel , Sys) -> maybe_el(2, Sys#sys.kernel);
pull_sys_d(user , Sys) -> maybe_el(2, Sys#sys.user).
pull_sys(atom , Sys) -> maybe_el(1, Sys#sys.atom);
pull_sys(beam_vsz , Sys) -> maybe_el(1, Sys#sys.beam_vsz);
pull_sys(binary , Sys) -> maybe_el(1, Sys#sys.binary);
pull_sys(code , Sys) -> maybe_el(1, Sys#sys.code);
pull_sys(ets , Sys) -> maybe_el(1, Sys#sys.ets);
pull_sys(total , Sys) -> maybe_el(1, Sys#sys.total);
pull_sys(now , Sys) -> maybe_el(1, Sys#sys.now);
pull_sys(prcs , Sys) -> maybe_el(1, Sys#sys.prcs);
pull_sys(processes , Sys) -> maybe_el(1, Sys#sys.processes);
pull_sys(run_queue , Sys) -> maybe_el(1, Sys#sys.run_queue).
get_sys_data(LD) ->
{Ctxt, 0} = erlang:statistics(context_switches),
{GCs, GCwords, 0} = erlang:statistics(garbage_collection),
{{input, IoIn}, {output, IoOut}} = erlang:statistics(io),
{Reds, _} = erlang:statistics(reductions),
OS = os_info(LD#ld.strategy),
#sys
{now = erlang:timestamp(),
prcs = erlang:system_info(process_count),
context_switches = Ctxt,
gcs = GCs,
gc_reclaimed = GCwords,
io_in = IoIn,
io_out = IoOut,
reductions = Reds,
run_queue = erlang:statistics(run_queue),
total = erlang:memory(total),
processes = erlang:memory(processes),
processes_used = erlang:memory(processes_used),
system = erlang:memory(system),
atom = erlang:memory(atom),
atom_used = erlang:memory(atom_used),
binary = erlang:memory(binary),
code = erlang:memory(code),
ets = erlang:memory(ets),
user = OS#sys_os.user,
nice = OS#sys_os.nice,
kernel = OS#sys_os.kernel,
idle = OS#sys_os.idle,
iowait = OS#sys_os.iowait,
beam_user = OS#sys_os.beam_user,
beam_kernel = OS#sys_os.beam_sys,
beam_vsz = OS#sys_os.vsz,
beam_rss = OS#sys_os.rss,
beam_minflt = OS#sys_os.minflt,
beam_majflt = OS#sys_os.majflt,
cores = (LD#ld.constants)#sys_const.cores,
total_ram = (LD#ld.constants)#sys_const.total_ram}.
constants(#ld{strategy = {linux, ProcStat, _}}) ->
#sys_const{total_ram = total_ram(),
cores = cores(ProcStat)};
constants(_) ->
#sys_const{}.
strategy() ->
case os:type() of
{unix, linux} -> init_linux();
{unix, darwin} -> init_ps();
_ -> {}
end.
%% OS info
os_info({linux, ProcStat, ProcSelfStat}) ->
proc_stat(ProcStat, proc_self_stat(ProcSelfStat, #sys_os{}));
os_info({ps, Port, Cmd}) ->
do_ps(Port, Cmd, #sys_os{});
os_info(_) ->
#sys_os{}.
proc_stat(FD, OS) ->
%%user nice kernel idle iowait irq softirq steal
{ok, Str} = file:pread(FD, 0, 200),
[User, Nice, Kernel, Idle, Iowait] =
case string:tokens(Str, " \n") of
["cpu", I1, I2, I3, I4, I5|_] -> [I1, I2, I3, I4, I5];
_ -> [0, 0, 0, 0, 0]
end,
OS#sys_os{
user = jiffy_to_sec(User),
nice = jiffy_to_sec(Nice),
kernel = jiffy_to_sec(Kernel),
idle = jiffy_to_sec(Idle),
iowait = jiffy_to_sec(Iowait)}.
proc_self_stat(FD, OS) ->
{ok, Str} = file:pread(FD, 0, 200),
{Minflt, Majflt, Utime, Stime, Vsz, Rss} = proc_self_stat(Str),
OS#sys_os{
beam_user = jiffy_to_sec(Utime),
beam_sys = jiffy_to_sec(Stime),
vsz = to_int(Vsz), %% in bytes
rss = to_int(Rss), %% in pages...
minflt = to_int(Minflt),
majflt = to_int(Majflt)}.
%%% pid, comm, state, ppid, pgrp, session, tty_nr, tpgid, flags,
%%% minflt, cminflt, majflt, cmajflt, utime, stime, cutime, cstime,
%%% priority, nice, num_threads, itrealvalue, starttime, vsize, rss
proc_self_stat(Str) ->
case string:tokens(Str, " ") of
[_, _, _, _, _, _, _, _, _, I10, _, I12, _,
I14, I15, _, _, _, _, _, _, _, I23, I24|_] ->
{I10, I12, I14, I15, I23, I24};
_ ->
{0, 0, 0, 0, 0, 0}
end.
jiffy_to_sec(J) ->
to_int(J)/100. %should use a better transform jiffies->secs
init_linux() ->
{ok, ProcStat} = file:open("/proc/stat", [read, raw]),
{ok, ProcSelfStat} = file:open("/proc/self/stat", [read, raw]),
{linux, ProcStat, ProcSelfStat}.
cores({linux, ProcStat, _}) ->
{ok, Str} = file:pread(ProcStat, 0, 1000),
Toks = string:tokens(Str, "\n"),
case length(lists:takewhile(fun(S)->lists:prefix("cpu", S) end, Toks)) of
1 -> 1;
M -> M-1
end;
cores(_) ->
1.
total_ram() ->
case file:open("/proc/meminfo", [read, raw]) of
{ok, FD} ->
try {ok, Str} = file:pread(FD, 0, 30),
["MemTotal:", T, "kB"|_] = string:tokens(Str, " \n"),
to_int(T)*1024
catch _:_ -> 0
after file:close(FD)
end;
_ -> 0
end.
init_ps() ->
{ps,
open_port({spawn, "/bin/sh"}, [stream]),
"ps -o pid,utime,time,vsz,rss,majflt,minflt -p "++os:getpid()++"\n"}.
%%% iostat -w1 -c2 -dC | tail -n1 | awk '{print $4,$5}' && ps -o pid,utime,time,vsz,rss,majflt,minflt -p
do_ps(Port, Cmd, OS) ->
Data = get_ps_data(Port, Cmd),
case[string:tokens(L, " ") || L <- string:tokens(Data, "\n")] of
[["PID", "UTIME", "TIME", "VSZ", "RSS", "MAJFLT", "MINFLT"],
%%% ["1", "0:00.20", "0:00.30", "2488932", "12600", "-", "-"]]
[_, Utime, Time, Vsz, Rss, MajFault, MinFault]] ->
UtimeSec = timestr_to_sec(Utime),
TimeSec = timestr_to_sec(Time), %system+user time
OS#sys_os
{beam_user = UtimeSec,
beam_sys = TimeSec-UtimeSec,
vsz = to_int(Vsz)*1024, % to bytes
rss = to_int(Rss), % in kB pages
minflt = to_int(MinFault),
majflt = to_int(MajFault)};
_ ->
OS
end.
get_ps_data(Port, Cmd) ->
case port_command(Port, Cmd, []) of
true ->
receive
{Port, {data, Data}} -> Data
end;
false ->
[]
end.
%% "8:11.15"
timestr_to_sec(Str) ->
case string:tokens(Str, ":.") of
[Min, Sec, CentiSec] -> 60*to_int(Min)+to_int(Sec)+to_int(CentiSec)/100;
_ -> 0
end.
%%%-------------------------------------------------------------------
%% collect info about an erlang process.
%% uses erlang:process_info/2
-record(prc,
{pid,
cpu, %% reductions * cpu_per_reduction
reductions, %% integer()
memory, %% bytes
message_queue_len, %% integer()
current_function, %% {M, F, A}
initial_call, %% {M, F, A}
registered_name, %% atom | []
last_calls, %% [{M, F, A}]
stack_size, %% bytes
heap_size, %% bytes
total_heap_size}). %% bytes
index_prc(pid) -> #prc.pid.
pull_prc_d(reductions, Prc) -> maybe_el(2, Prc#prc.reductions).
pull_prc(pid , Prc) -> maybe_el(1, Prc#prc.pid);
pull_prc(current_function , Prc) -> maybe_el(1, Prc#prc.current_function);
pull_prc(message_queue_len , Prc) -> maybe_el(1, Prc#prc.message_queue_len);
pull_prc(memory , Prc) -> maybe_el(1, Prc#prc.memory);
pull_prc(cpu , Prc) -> maybe_el(1, Prc#prc.cpu);
pull_prc(registered_name , Prc) -> maybe_el(1, Prc#prc.registered_name);
pull_prc(initial_call , Prc) -> maybe_el(1, Prc#prc.initial_call).
get_prc_data(LD) ->
case LD#ld.max_prcs < erlang:system_info(process_count) of
true -> [];
false -> lists:map(fun prc_info/1, lists:sort(processes()))
end.
prc_info(Pid) ->
#prc{
pid = Pid,
memory = prc_info(Pid, memory),
reductions = prc_info(Pid, reductions),
message_queue_len = prc_info(Pid, message_queue_len)}.
complete(Prc, CpuPerRed) ->
Pid = Prc#prc.pid,
Prc#prc{
cpu = CpuPerRed*pull_prc_d(reductions, Prc),
current_function = prc_info(Pid, current_function),
initial_call = prc_info(Pid, initial_call),
registered_name = prc_info(Pid, registered_name),
last_calls = prc_info(Pid, last_calls),
stack_size = prc_info(Pid, stack_size),
heap_size = prc_info(Pid, heap_size),
total_heap_size = prc_info(Pid, total_heap_size)}.
prc_info(Pid, Tag) ->
case erlang:process_info(Pid, Tag) of
undefined -> get_default(Tag, Pid);
[] when Tag == registered_name -> mod_val(Pid, Tag, "");
{Tag, Val} -> mod_val(Pid, Tag, Val)
end.
get_default(Tag, Pid) ->
{_, Default} = prcinfo(Tag, Pid),
Default.
mod_val(Pid, Tag, Val) ->
{Modder, _} = prcinfo(Tag, Pid),
Modder(Val).
prcinfo(stack_size, _) ->
{fun(Val) -> 8*Val end,
0};
prcinfo(heap_size, _) ->
{fun(Val) -> 8*Val end,
0};
prcinfo(total_heap_size, _) ->
{fun(Val) -> 8*Val end,
0};
prcinfo(reductions, _) ->
{fun(Val) -> Val end,
0};
prcinfo(last_calls, Pid) ->
{fun(Val) ->
case Val of
false -> try process_flag(Pid, save_calls, 16)
catch _:_ -> ok end,
[];
Calls -> lists:usort(Calls)
end
end,
[]};
prcinfo(registered_name, _) ->
{fun(Val) -> Val end,
[]};
prcinfo(initial_call, Pid) ->
{fun(Val) ->
case Val of
{proc_lib, init_p, 5} ->
try proc_lib:translate_initial_call(Pid) of
{dets, init, 2} -> pinf_dets(Pid);
{disk_log, init, 2} -> pinf_disk_log(Pid);
IC -> IC
catch _:_ ->
Val
end;
_ -> Val
end
end,
[]};
prcinfo(_, _) ->
{fun(Val) -> Val end,
[]}.
pinf_dets(Pid) ->
case dets:pid2name(Pid) of
{ok, Dets} -> {dets, Dets};
undefined -> undefined_dets_table
end.
pinf_disk_log(Pid) ->
case disk_log:pid2name(Pid) of
{ok, Log} -> {disk_log, Log};
undefined -> undefined_disk_log
end.
%%----------------------------------------------------------------------------------------
%% network activity
-include_lib("kernel/include/inet.hrl").
-record(net, {name,
port,
input,
output,
recv_avg,
recv_cnt,
recv_dvi,
recv_max,
recv_oct,
send_avg,
send_cnt,
send_max,
send_oct,
send_pend}).
index_net(port) -> #net.port.
push_net({recv_avg, V}, Net) -> Net#net{recv_avg = V};
push_net({recv_cnt, V}, Net) -> Net#net{recv_cnt = V};
push_net({recv_dvi, V}, Net) -> Net#net{recv_dvi = V};
push_net({recv_max, V}, Net) -> Net#net{recv_max = V};
push_net({recv_oct, V}, Net) -> Net#net{recv_oct = V};
push_net({send_avg, V}, Net) -> Net#net{send_avg = V};
push_net({send_cnt, V}, Net) -> Net#net{send_cnt = V};
push_net({send_max, V}, Net) -> Net#net{send_max = V};
push_net({send_oct, V}, Net) -> Net#net{send_oct = V};
push_net({send_pend,V}, Net) -> Net#net{send_pend = V}.
get_net_data() ->
lists:map(fun port_info/1, lists:sort(erlang:ports())).
%%returns #net{}
port_info(P) ->
try maybe_inet(#net{port = P,
name = name(P),
input = erlang:port_info(P, input),
output = erlang:port_info(P, output)})
catch _:_ -> #net{port = P}
end.
maybe_inet(Net = #net{name = "tcp"++_}) -> add_inet(Net);
maybe_inet(Net = #net{name = "udp"++_}) -> add_inet(Net);
maybe_inet(Net) -> Net.
add_inet(Net = #net{port = Port}) ->
try {ok, Stats} = inet:getstat(Port),
lists:foldl(fun push_net/2, Net, Stats)
catch _:_ -> Net
end.
name(P) ->
case erlang:port_info(P, name) of
{name, "udp_inet"} ->
{ok, Port} = inet:port(P),
flat("udp:~p", [Port]);
{name, "tcp_inet"} ->
{ok, {IP, Port}} = inet:peername(P),
flat("tcp:~p:~p-~s", [IP, Port, tcp_name(IP, Port)]);
{name, Name} ->
Name
end.
tcp_name(IP, Port) ->
case inet:gethostbyaddr(IP) of
{ok, #hostent{h_name = HostName}} ->
try
{ok, Socket} = gen_tcp:connect(IP, 4369, [inet], 100),
inet:close(Socket),
{ok, Names} = erl_epmd:names(IP),
{value, {NodeName, Port}} = lists:keysearch(Port, 2, Names),
NodeName++"@"++HostName
catch
_:_ -> HostName
end;
_ ->
""
end.
%%----------------------------------------------------------------------------------------
%% mnesia activity
-record(mnesia,
{logged_transactions,
restarted_transactions,
committed_transactions,
failed_transactions,
current_transactions,
object_counts,
table_sizes,
subscribers,
lock_queue,
held_locks}).
get_mnesia_data() ->
try mnesia:system_info(is_running) of
no -> {};
yes -> mnesia()
catch
_:_ -> {}
end.
mnesia() ->
#mnesia{
held_locks = held_locks(),
lock_queue = lock_queue(),
subscribers = subscribers(),
table_sizes = table_sizes(),
object_counts = object_counts(),
current_transactions = current_transactions(),
failed_transactions = failed_transactions(),
committed_transactions = committed_transactions(),
restarted_transactions = restarted_transactions(),
logged_transactions = logged_transactions()}.
%%%_* mnesia stats ============================================================
-type table_name() :: dets:tab_name() | ets:tab().
-type table_type() :: dets | ets | undefined.
-type bytes() :: non_neg_integer().
-type count() :: non_neg_integer().
-spec held_locks() -> count().
held_locks() ->
ets:info(mnesia_held_locks, size).
-spec lock_queue() -> count().
lock_queue() ->
ets:info(mnesia_lock_queue, size).
-spec subscribers() -> [pid()].
subscribers() ->
mnesia:system_info(subscribers).
-spec tables() -> [table_name()].
tables() ->
mnesia:system_info(tables).
%% NB: Table size is in bytes
-spec table_sizes() -> [{table_name(), bytes()}].
table_sizes() ->
F = fun(Table, Acc) ->
case table_size(Table) of
undefined -> Acc;
Size -> [{Table, Size}|Acc]
end
end,
lists:foldl(F, [], tables()).
-spec object_counts() -> [{table_name(), count()}].
object_counts() ->
F = fun(Table, Acc) ->
case object_count(Table) of
undefined -> Acc;
Count -> [{Table, Count}|Acc]
end
end,
lists:foldl(F, [], tables()).
-spec current_transactions() -> count().
current_transactions() ->
length(mnesia:system_info(transactions)).
-spec failed_transactions() -> count().
failed_transactions() ->
mnesia:system_info(transaction_failures).
-spec committed_transactions() -> count().
committed_transactions() ->
mnesia:system_info(transaction_commits).
-spec restarted_transactions() -> count().
restarted_transactions() ->
mnesia:system_info(transaction_restarts).
-spec logged_transactions() -> count().
logged_transactions() ->
mnesia:system_info(transaction_log_writes).
-spec object_count(table_name()) -> count() | undefined.
object_count(Table) ->
object_count(Table, get_term_storage_type(Table)).
-spec object_count(table_name(), table_type()) -> count() | undefined.
object_count(_Table, undefined) -> undefined;
object_count(Table, dets) -> dets_object_count(Table);
object_count(Table, ets) -> ets_object_count(Table).
-spec table_size(table_name()) -> bytes() | undefined.
table_size(Table) ->
table_size(Table, get_term_storage_type(Table)).
-spec table_size(table_name(), table_type()) -> bytes() | undefined.
table_size(_Table, undefined) -> undefined;
table_size(Table, dets) -> dets_size(Table);
table_size(Table, ets) -> ets_size(Table).
-spec get_term_storage_type(table_name()) -> table_type().
get_term_storage_type(Table) ->
case mnesia:table_info(Table, storage_type) of
disc_copies -> ets;
disc_only_copies -> dets;
_ -> undefined
end.
-spec dets_size(dets:tab_name()) -> bytes().
dets_size(Table) ->
dets:info(Table, file_size).
-spec dets_object_count(dets:tab_name()) -> count().
dets_object_count(Table) ->
dets:info(Table, size).
-spec ets_size(ets:tab()) -> bytes().
ets_size(Table) ->
ets:info(Table, memory) * erlang:system_info(wordsize).
-spec ets_object_count(ets:tab()) -> count().
ets_object_count(Table) ->
ets:info(Table, size).
%% ---------------------------------------------------------------
%% utils
flat(F, A) ->
lists:flatten(io_lib:fwrite(F, A)).
to_list(A) when is_list(A) -> A;
to_list(A) when is_pid(A) -> pid_to_list(A);
to_list(A) when is_atom(A) -> atom_to_list(A);
to_list(A) when is_float(A) -> to_list(round(A));
to_list(A) when is_tuple(A) -> tuple_to_list(A);
to_list(A) when is_integer(A) -> integer_to_list(A).
to_int("-") -> 0;
to_int(J) -> list_to_integer(J).
%%make ints human readable
human(X) when not is_number(X) -> X;
human(I) when I < 0 -> "-"++human(-I);
human(I) when 0 < I ->
case math:log10(I) of
M when 15 =< M -> human(M-15,"P");
M when 12 =< M -> human(M-12,"T");
M when 9 =< M -> human(M-9,"G");
M when 6 =< M -> human(M-6,"M");
M when 3 =< M -> human(M-3,"k");
_ -> flat("~w",[I])
end;
human(_) -> "0".
human(E, M) ->
flat("~.1f~s", [math:pow(10,E), M]).
delta_time(TS0, TS1) -> timer:now_diff(TS0, TS1)/1000000.
maybe_el(1, {E, _}) -> E;
maybe_el(2, {_, E}) -> E;
maybe_el(_, E) -> E.