Current section
Files
Jump to
Current section
Files
src/tr_ttb.erl
%% -*- mode: erlang; indent-tabs-mode: nil; -*-
%%---- BEGIN COPYRIGHT -------------------------------------------------------
%%
%% Copyright (C) 2016 Ulf Wiger. All rights reserved.
%%
%% This Source Code Form is subject to the terms of the Mozilla Public
%% License, v. 2.0. If a copy of the MPL was not distributed with this
%% file, You can obtain one at http://mozilla.org/MPL/2.0/.
%%
%%---- END COPYRIGHT ---------------------------------------------------------
-module(tr_ttb).
-export([ event/1 ]).
-export([ dbg_tracer/0
, dbg_tracer/1
, dbg_stop/0 ]).
-export([
on_nodes/2,
on_nodes/3,
on_nodes/4,
default_patterns/0,
default_flags/0,
stop/0,
stop_nofetch/0,
format/1,
format/2,
format/3,
format_opts/0,
format_opts/1,
handler/4,
pp/3,
pp_term/2, %% (Term, Module | F((T) -> {yes, T1} | no)) -> Term1
pp_custom/3, %% (Term, Tag, Fmt((X) -> X1)) -> Term1
record_print_fun/1
]).
-export([ cfg/3 ]).
-export([ shell_records_tab/0 ]).
-export_type([ flag/0, flags/0,
pattern/0, patterns/0,
proc/0 ]).
-type trace_pat() :: any().
-type pattern() :: {module(), atom(), arity(), trace_pat()}.
-type patterns() :: [pattern()].
-type proc() :: pid() | port() | atom() | {global,any()}
| all | processes | ports | existing | existing_processes
| existing_ports | new | new_processes | new_ports.
-type procs() :: proc() | [proc()].
-type flag() :: clear | all
| m | s | r | c | call | p | sos | sol | sofs | sofl
| send | 'receive' | call | procs | ports | garbage_collection
| running | set_on_spawn | set_on_first_spawn | set_on_link
| set_on_first_link | timestamp | monotonic_timestamp
| strict_monotonic_timestamp | arity | return_to | silent
| running_procs | running_ports | exiting.
-type flags() :: flag() | [flag()].
-callback flags() -> {procs(), flags()}.
-callback patterns() -> [pattern()].
-define(EVENT(E, S), event(?LINE, E, S)).
%% This function is also traced. Can be used to insert markers in the trace
%% log.
event(E) ->
event(?LINE, E, none).
event(_, _, _) ->
ok.
dbg_tracer() ->
dbg_tracer(#{}).
dbg_tracer(Opts) when is_map(Opts) ->
St0 = init_state(maps:merge(#{ fd => group_leader()
, print_header => false }, Opts)),
dbg:tracer(process, {fun dhandler/2, St0}).
dbg_stop() ->
await_traces(),
dbg:stop().
shell_records_tab() ->
case find_shell_process() of
ShellPid when is_pid(ShellPid) ->
case [T || T <- ets:all(),
ets:info(T, owner) == ShellPid
andalso ets:info(T, name) == shell_records] of
[RecTab] ->
RecTab;
[] ->
undefined
end;
_ ->
undefined
end.
find_shell_process() ->
find_shell_process(group_leader()).
find_shell_process(GL) ->
case lists:keyfind(shell, 1, pi(GL, dictionary)) of
{_, Pid} ->
Pid;
false ->
case pi(GL, group_leader) of
GL -> undefined;
GL1 -> find_shell_process(GL1)
end
end.
pi(P, Key) when is_pid(P) ->
{_, I} = process_info(P, Key),
I.
await_traces() ->
case dbg:get_tracer() of
{ok, Tracer} ->
await_tracer(process_info(Tracer, message_queue_len), Tracer);
{error, _} ->
ok
end.
await_tracer({message_queue_len, L}, Tracer) when L > 3 ->
timer:sleep(10),
await_tracer(process_info(Tracer, message_queue_len), Tracer);
await_tracer(_, _) ->
ok.
on_nodes(Ns, File) ->
on_nodes(Ns, default_patterns(), default_flags(), [{file, File}]).
on_nodes(Ns, File, Spec) ->
on_nodes(Ns,
cfg(Spec, patterns, default_patterns()),
cfg(Spec, flags, default_flags()),
[ {file, File}
, {tr_ttb_info, cfg(Spec, info, undefined)}]).
-spec on_nodes([node()], [pattern()], {procs(), flags()}, list()) ->
{ok,list()} | {error, any()}.
on_nodes(Ns, Patterns0, Flags, Opts0) ->
Opts = lists:keydelete(tr_ttb_info, 1, Opts0),
Patterns = expand_patterns(Patterns0),
Res = ttb_start_trace(Ns, Patterns, Flags, Opts),
?EVENT(ttb_started, maybe_info(#{ nodes => Ns
, patterns => Patterns
, flags => Flags }, Opts0)),
Res.
maybe_info(Map, Opts) ->
case lists:keyfind(tr_ttb_info, 1, Opts) of
{_, Info} when Info =/= undefined ->
Map#{info => Info};
_ ->
Map
end.
ttb_start_trace(Ns, Patterns, Flags, Opts) ->
Start = maps:get(start, Patterns, []),
Res = ttb:start_trace(Ns, Start, Flags, Opts),
maps:fold(
fun(Op, Pats, _) when Op==tp; Op==tpl->
[ttb:Op(M,F,A,MS) || {M,F,A,MS} <- Pats];
(Op, Pats, _) when Op==ctp; Op==ctpl; Op==ctpg ->
[ttb:Op(M,F,A) || {M,F,A} <- Pats];
(tpe, Pats, _) ->
[dbg:tpe(E, MS) || {E, MS} <- Pats];
(ctpe, Pats, _) ->
[dbg:ctpe(E) || E <- Pats]
end, ok, maps:without([start], Patterns)),
Res.
expand_patterns(Patterns) when is_map(Patterns) ->
maps:merge(Patterns,
maps:map(fun(_K, V) when is_list(V) ->
[expand_pat(P) || P <- V];
(_, V) -> V
end,
maps:with([start,tp,tpl], Patterns)));
expand_patterns(Patterns) when is_list(Patterns) ->
#{start => [expand_pat(P) || P <- Patterns]}.
expand_pat(P) when is_tuple(P) ->
Sz = tuple_size(P),
case element(Sz, P) of
x ->
setelement(Sz, P, [{'_',[],[{exception_trace}]}]);
_ ->
P
end;
expand_pat(P) ->
P.
-spec default_patterns() -> [pattern()].
default_patterns() ->
[{?MODULE , event, 3, []}].
-spec default_flags() -> {procs(), flags()}.
default_flags() ->
{all, call}.
stop() ->
{stopped, Dir} = ttb:stop([return_fetch_dir]),
Dir.
stop_nofetch() ->
ttb:stop([nofetch]).
format(Dir) ->
format(Dir, standard_io).
format(Dir, OutFile) ->
format(Dir, OutFile, #{}).
format(Dir, OutFile, Opts) ->
try ttb:format(Dir, format_opts(OutFile, Opts))
catch
error:exceeded_limit = Reason ->
{error, Reason};
error:Other:ST ->
{error, {Other, ST}}
end.
format_opts() ->
format_opts(standard_io).
format_opts(Outfile) ->
format_opts(Outfile, #{}).
format_opts(OutFile, Opts0) ->
Opts = maps:merge(#{limit => 10000}, Opts0),
[{out, OutFile}, {handler, {fun handler/4, init_state(Opts)}}].
init_state(Opts0) ->
Opts = maps:merge(#{ ts => 0
, diff => 0
, limit => infinity
, sofar => 0
, opts => Opts0 }, Opts0),
case Opts of
#{shell_records := true, shell_records_tab := _} ->
Opts;
#{shell_records := true} ->
case shell_records_tab() of
undefined ->
maps:without([shell_records, shell_records_tab], Opts);
Tab ->
Opts#{shell_records_tab => Tab}
end;
_ ->
Opts
end.
%% Real-time handler (see dbg_tracer/1
dhandler(end_of_trace, St) ->
St;
dhandler(Trace, #{fd := Fd} = St) ->
handler(Fd, Trace, [], St).
handler(Fd, Trace, TI, #{delay := D} = Acc) ->
timer:sleep(D),
handler(Fd, Trace, TI, maps:remove(delay, Acc));
handler(_, _, _, #{limit_exceeded := true} = Acc) ->
Acc;
handler(Fd, Trace, TI, Acc) ->
try Res = handler_(Fd, Trace, TI, Acc),
Res
catch
error:limit_exceeded ->
Acc#{limit_exceeded => true};
Caught:E:ST ->
fwrite(user, "CAUGHT ~p:~p:~p~nTrace=~p", [Caught, E, ST, Trace]),
Acc
end.
handler_(Fd, Trace, _, #{ts := TSp, diff := Diff, sofar := Sofar} = Acc) ->
TS = ts(Trace, TSp),
L0 = case {TSp,Diff} of {0,0} ->
case maps:get(print_header, Acc, true) of
true ->
io:fwrite(Fd, "%% -*- erlang -*-~n", []),
io:put_chars(Fd, format_time(TS)),
2;
_ ->
0
end;
_ -> 0
end,
Tdiff = tdiff(TS, TSp, time_resolution(Acc)),
Diff1 = Diff + Tdiff,
Sofar1 = Sofar + L0,
Acc1 = Acc#{sofar => Sofar1, ts => TS, diff => Diff1},
check_limit_exceeded(Acc1),
Lines =
case Trace of
{trace_ts, From, call, {Mod, Fun, Args}, TS} ->
{Pid, Node} = pid_and_node(From),
print_call(Fd, Pid, Node, Mod, Fun, Args, Diff1, Acc);
{trace_ts, From, Type, {Mod, Fun, Arity}, Info, TS}
when Type =:= return_from; Type =:= exception_from ->
{Pid, Node} = pid_and_node(From),
print_return(Fd, Type, Pid, Node, Mod, Fun, Arity, Info, Diff1, Acc);
{trace_ts, From, Type, Info, TS} ->
{Pid, Node} = pid_and_node(From),
print_other(Fd, #{type => Type}, Pid, Node, Info, Diff1, Acc);
{trace_ts, From, Type, Arg, Info, TS} ->
{Pid, Node} = pid_and_node(From),
print_other(Fd, #{type => Type, arg => Arg}, Pid, Node, Info, Diff1, Acc);
TraceTS when element(1, TraceTS) == trace_ts ->
fwrite(Fd, "~p~n", [Trace]);
_ ->
fwrite(Fd, "~p~n", [Trace])
end,
Acc1#{sofar => Sofar1 + Lines}.
pid_and_node({Pid, _, Node}) ->
{Pid, Node};
pid_and_node(Pid) when is_pid(Pid); is_port(Pid) ->
{Pid, local}.
fwrite(Fd, Fmt, Args) ->
io_reqs(Fd, [{put_chars, fwrite(Fmt, Args)}]).
io_reqs(Fd, Rs) ->
Lines = count_lines(Rs),
io:requests(Fd, Rs),
Lines.
count_lines(Rs) ->
lists:foldl(
fun(nl, Acc) -> Acc+1;
({put_chars, Cs}, Acc) ->
count_newlines(Cs) + Acc;
({put_chars, unicode, Cs}, Acc) ->
count_newlines(Cs) + Acc
end, 0, Rs).
count_newlines(Cs) ->
case re:run(Cs, <<"\\v">>, [global]) of
{match, Ms} ->
length(Ms);
nomatch ->
0
end.
check_limit_exceeded(#{sofar := Sofar, limit := Limit}) ->
if Sofar > Limit ->
error(limit_exceeded);
true ->
ok
end.
ts(Trace, _TSp) when element(1, Trace) == trace_ts ->
Sz = tuple_size(Trace),
element(Sz, Trace);
ts(_, 0) ->
erlang:timestamp();
ts(_, TSp) ->
TSp.
print_call(Fd, Pid, Node, Mod, Fun, Args, Diff, Acc) ->
case {Fun, Args} of
{event, [Line, Evt, State]} when is_integer(Line) ->
Lines = print_evt(Fd, Pid, Node, Mod, Line, Evt, State, Diff, Acc),
case get_pids({Evt, State}) of
[] -> Lines;
Pids ->
Lines1 = fwrite(Fd, " Nodes = ~p~n", [Pids]),
Lines + Lines1
end;
_ ->
print_call_(Fd, Pid, Node, Mod, Fun, Args, Diff, Acc)
end.
print_return(Fd, Type, Pid, Node, Mod, Fun, Arity, Info, T, Acc) ->
Tstr = fwrite("~w", [T]),
Indent = iolist_size(Tstr) + 3 + 4,
Head = print_return_head(Type, Pid, Node, Mod, Fun, Arity),
Line1Len = iolist_size([Tstr, Head]),
InfoPP = pp(Info, 1, Mod, Acc),
Res = case fits_on_line(InfoPP, Line1Len, 79) of %% minus space
true -> [" ", InfoPP];
false ->
["\n", indent(Indent), pp(Info, Indent, Mod, Acc)]
end,
io_reqs(Fd, [{put_chars, unicode, [Tstr, Head, Res]}, nl]).
print_other(Fd, Type, Pid, Node, Info, T, Acc) ->
Tstr = fwrite("~w", [T]),
Indent = iolist_size(Tstr) + 3 + 4,
Head = print_other_head(Pid, Node, Type),
Line1Len = iolist_size([Tstr, Head]),
Mod = guess_mod(Type, Info),
InfoPP = pp(Info, 1, Mod, Acc),
Res = case fits_on_line(InfoPP, Line1Len, 79) of
true -> [" ", InfoPP];
false ->
["\n", indent(Indent), pp(Info, Indent, Mod, Acc)]
end,
io_reqs(Fd, [{put_chars, unicode, [Tstr, Head, Res]}, nl]).
typestr(return_from ) -> "->";
typestr(exception_from) -> "xx~~>".
guess_mod(Type, Info) ->
guess_mod(Type, Info, ?MODULE).
guess_mod(#{type := exit}, {_, [{Mod, _, _}|_]}, Default) when is_atom(Mod) ->
case erlang:function_exported(Mod, module_info, 0) of
true -> Mod;
false -> Default
end;
guess_mod(_, {erlang, apply, [Mod|_]}, _) when is_atom(Mod) ->
Mod;
guess_mod(_, {erlang, apply, [F|_]}, _) when is_function(F) ->
{_, Mod} = erlang:fun_info(F, module),
Mod;
guess_mod(_, _, Default) ->
Default.
-define(CHAR_MAX, 60).
print_evt(Fd, Pid, N, Mod, L, E, St, T, Acc) ->
Tstr = fwrite("~w", [T]),
Indent = iolist_size(Tstr) + 3,
Head = case N of
local -> fwrite(" - ~w|~w/~w: " , [Pid, Mod, L]);
_ -> fwrite(" - ~w~w|~w/~w: ", [Pid, N, Mod, L])
end,
EvtCol = iolist_size(Head) + 1,
EvtCs = pp(E, EvtCol, Mod, Acc),
io_reqs(Fd, [{put_chars, unicode, [Tstr, Head, EvtCs]}, nl
| print_tail(St, Mod, Indent, Acc)]).
print_call_(Fd, Pid, N, Mod, Fun, Args, T, Acc) ->
Tstr = fwrite("~w", [T]),
Indent = iolist_size(Tstr) + 3 + 4,
Head = print_call_head(Pid, N, Mod, Fun),
Line1Len = iolist_size([Tstr, Head]),
PlainArgs = pp_args(Args, 1, Mod, Acc),
Rest = case fits_on_line(PlainArgs, Line1Len, 79) of %% minus )
true -> [PlainArgs, ")"];
false ->
["\n", indent(Indent),
pp_args(Args, Indent, Mod, Acc), ")"]
end,
io_reqs(Fd, [{put_chars, unicode, [Tstr, Head, Rest]}, nl]).
print_call_head(Pid, N, Mod, Fun) ->
case N of
local -> fwrite(" - ~w|~w:~w(" , [Pid, Mod, Fun]);
_ -> fwrite(" - ~w~w|~w:~w(", [Pid, N, Mod, Fun])
end.
print_other_head(Pid, N, #{type := Type, arg := Arg}) ->
case N of
local -> fwrite(" - ~w|~w[~w]:", [Pid, Type, Arg]);
_ -> fwrite(" - ~w~w|~w[~w]:", [Pid, N, Type, Arg])
end;
print_other_head(Pid, N, #{type := Type}) ->
case N of
local -> fwrite(" - ~w|~w:", [Pid, Type]);
_ -> fwrite(" - ~w~w|~w", [Pid, N, Type])
end.
print_return_head(Type, Pid, Node, Mod, Fun, Arity) ->
case Node of
local -> fwrite(" - ~w|~w:~w/~w " ++ typestr(Type), [Pid, Mod, Fun, Arity]);
_ -> fwrite(" - ~w~w|~w:~w/~w " ++ typestr(Type), [Pid, Node, Mod, Fun, Arity])
end.
fwrite(Fmt, Args) ->
io_lib:fwrite(Fmt, Args).
indent(N) ->
lists:duplicate(N, $\s).
rm_braces(Str) ->
%% allow for whitespace (incl vertical) before and after
B = iolist_to_binary(Str),
Sz = byte_size(B),
{Open,1} = binary:match(B, [<<"{">>]),
{Close,1} = lists:last(
binary:matches(B, [<<"}">>])),
SzA = Open + 1,
SzB = Sz-Close,
SzMid = Sz - SzA - SzB,
<<_:SzA/unit:8,Mid:SzMid/binary,_/binary>> = B,
Mid.
fits_on_line(IOList, Len, LineLen) ->
iolist_size(IOList) + Len =< LineLen
andalso has_no_line_breaks(IOList).
has_no_line_breaks(IOL) ->
nomatch =:= re:run(IOL, <<"\\v">>).
print_tail(none, _, _Col, _Acc) -> [];
print_tail(St, Mod, Col, Acc) ->
Cs = pp(St, Col+1, Mod, Acc),
[{put_chars, unicode, [lists:duplicate(Col,$\s), Cs]}, nl].
%% Pretty-printing the args list as a list, may trigger the 'string' interpretation
%% of the list. We want to remove the brackets anyway, so convert to tuple, then remove the braces
pp_args(Args, Col, Mod, Acc) ->
rm_braces(pp(list_to_tuple(Args), Col, Mod, Acc)).
pp(Term, Col, Mod) ->
pp(Term, Col, Mod, #{}).
pp(Term, Col, Mod, Acc) ->
Out = pp_term(Term, Mod),
io_lib_pretty:print(Out,
[{column, Col},
{line_length, 80},
{depth, -1},
{max_chars, ?CHAR_MAX},
{record_print_fun, record_print_fun(Mod, Acc)}]).
pp_term(T, M) when is_atom(M) ->
pp_term(T, fun M:pp_term/1);
pp_term(T, F) when is_function(F, 1) ->
try F(T) of
{yes, Out} -> Out;
no -> pp_term_(T, F)
catch
error:_ ->
pp_term_(T, F)
end.
pp_term_(D, _) when element(1, D) == dict ->
pp_custom(D, '$dict', fun dict_to_list/1);
pp_term_(T, M) when is_tuple(T) ->
list_to_tuple([pp_term(Trm, M) || Trm <- tuple_to_list(T)]);
pp_term_(L, M) when is_list(L) ->
%% Could be an improper list
lmap(L, fun(T) -> pp_term(T, M) end);
pp_term_(T, _) ->
T.
lmap([H|T], F) when is_list(T) ->
[F(H)|lmap(T,F)];
lmap([H|X], F) ->
[F(H)|F(X)];
lmap([], _) ->
[].
pp_custom(X, Tag, F) ->
try {Tag, F(X)}
catch
error:_ ->
{'ERROR-CUSTOM', Tag, X}
end.
tdiff(_, 0, _) -> 0;
tdiff(TS, T0, Res) ->
case Res of
millisecond ->
timer:now_diff(TS, T0) div 1000;
microsecond ->
timer:now_diff(TS, T0)
end.
time_resolution(Opts) ->
maps:get(time_resolution, Opts, millisecond).
record_print_fun(Mod) ->
record_print_fun(Mod, #{}).
record_print_fun(Mod, Acc) ->
fun(Tag, NoFields) ->
record_print_fun_(Mod, Tag, NoFields, [], Acc)
end.
record_print_fun_(Mod, Tag, NoFields, V, Acc) ->
case shell_record_print(Tag, NoFields, Acc) of
Fields when is_list(Fields) ->
Fields;
_ ->
try Mod:record_fields(Tag) of
Fields when is_list(Fields) ->
case length(Fields) of
NoFields -> Fields;
_ -> no
end;
{check_mods, Mods} when is_list(Mods) ->
check_mods(Mods, Tag, NoFields, V, Acc);
no -> no
catch
_:_ ->
no
end
end.
%% code copied and slightly modified from shell:record_print_fun/1
shell_record_print(Tag, NoFields, #{shell_records_tab := RT}) ->
try ets:lookup(RT, Tag) of
[{_,{attribute,_,record,{Tag,Fields}}}]
when length(Fields) =:= NoFields ->
record_fields(Fields);
_ ->
no
catch
error:_ ->
no
end;
shell_record_print(_, _, _) ->
no.
record_fields([{record_field,_,{atom,_,Field}} | Fs]) ->
[Field | record_fields(Fs)];
record_fields([{record_field,_,{atom,_,Field},_} | Fs]) ->
[Field | record_fields(Fs)];
record_fields([{typed_record_field,Field,_Type} | Fs]) ->
record_fields([Field | Fs]);
record_fields([]) ->
[].
check_mods([], _, _, _, _) ->
no;
check_mods([M|Mods], Tag, NoFields, V, Acc) ->
Cont = fun(V1) -> check_mods(Mods, Tag, NoFields, V1, Acc) end,
case lists:member(M, V) of
true ->
Cont(V);
false ->
V1 = [M|V],
try record_print_fun_(M, Tag, NoFields, V1, Acc) of
Fields when is_list(Fields) ->
Fields;
no ->
Cont(V1)
catch
_:_ ->
Cont(V1)
end
end.
get_pids(Term) ->
Pids = dict:to_list(get_pids(Term, dict:new())),
[{node_prefix(P), N} || {N, P} <- Pids].
get_pids(T, Acc) when is_tuple(T) ->
get_pids(tuple_to_list(T), Acc);
get_pids(L, Acc) when is_list(L) ->
get_pids_(L, Acc);
get_pids(P, Acc) when is_pid(P) ->
try ets:lookup(ttb, P) of
[{_, _, Node}] ->
dict:store(Node, P, Acc);
_ ->
Acc
catch
error:_ -> Acc
end;
get_pids(_, Acc) ->
Acc.
get_pids_([H|T], Acc) ->
get_pids_(T, get_pids(H, Acc));
get_pids_(_, Acc) ->
Acc.
node_prefix(P) ->
case re:run(pid_to_list(P), "[^<\\.]+", [{capture,first,list}]) of
{match, [Pfx]} ->
Pfx;
_ ->
P
end.
cfg(Mod, Key, Default) when is_atom(Mod) ->
try_callback(Mod, Key, [], Default);
cfg(Spec, Key, Default) when is_map(Spec) ->
case maps:find(Key, Spec) of
{ok, Res} -> Res;
error ->
case maps:get(module, Spec, undefined) of
undefined -> Default;
Mod ->
try_callback(Mod, Key, [], Default)
end
end.
try_callback(Mod, Key, Args, Default) ->
ensure_loaded(Mod),
case erlang:function_exported(Mod, Key, length(Args)) of
true ->
apply(Mod, Key, Args);
false ->
Default
end.
ensure_loaded(Mod) ->
case code:ensure_loaded(Mod) of
{module, _} ->
true;
{error, _} ->
false
end.
%% -dialyzer(no_opaque).
-dialyzer([{nowarn_function, dict_to_list/1}, no_opaque]).
dict_to_list(D) when element(1, D) == dict ->
dict:to_list(D).
-dialyzer({nowarn_function, format_time_/1}).
%% ==================================================================
%% Copied from lager_default_formatter.erl, lager_util.erl
format_time(Now) ->
{Date, Time} = format_time_(maybe_utc(localtime_ms(Now))),
["=== Start time: ", Date, " ", Time, " ===\n"].
format_time_({utc, {{Y, M, D}, {H, Mi, S, Ms}}}) ->
{[integer_to_list(Y), $-, i2l(M), $-, i2l(D)],
[i2l(H), $:, i2l(Mi), $:, i2l(S), $., i3l(Ms), $ , $U, $T, $C]};
format_time_({{Y, M, D}, {H, Mi, S, Ms}}) ->
{[integer_to_list(Y), $-, i2l(M), $-, i2l(D)],
[i2l(H), $:, i2l(Mi), $:, i2l(S), $., i3l(Ms)]};
format_time_({utc, {{Y, M, D}, {H, Mi, S}}}) ->
{[integer_to_list(Y), $-, i2l(M), $-, i2l(D)],
[i2l(H), $:, i2l(Mi), $:, i2l(S), $ , $U, $T, $C]};
format_time_({{Y, M, D}, {H, Mi, S}}) ->
{[integer_to_list(Y), $-, i2l(M), $-, i2l(D)],
[i2l(H), $:, i2l(Mi), $:, i2l(S)]}.
i2l(I) when I < 10 -> [$0, $0+I];
i2l(I) -> integer_to_list(I).
i3l(I) when I < 100 -> [$0 | i2l(I)];
i3l(I) -> integer_to_list(I).
localtime_ms(Now) ->
{_, _, Micro} = Now,
{Date, {Hours, Minutes, Seconds}} = calendar:now_to_local_time(Now),
{Date, {Hours, Minutes, Seconds, Micro div 1000 rem 1000}}.
maybe_utc({Date, {H, M, S, Ms}}) ->
case maybe_utc_({Date, {H, M, S}}) of
{utc, {Date1, {H1, M1, S1}}} ->
{utc, {Date1, {H1, M1, S1, Ms}}};
{Date1, {H1, M1, S1}} ->
{Date1, {H1, M1, S1, Ms}}
end.
maybe_utc_(Time) ->
UTC = case application:get_env(sasl, utc_log) of
{ok, Val} ->
Val;
undefined ->
%% Backwards compatible:
application:get_env(stdlib, utc_log, false)
end,
if
UTC =:= true ->
UTCTime = case calendar:local_time_to_universal_time_dst(Time) of
[] -> calendar:local_time();
[T0|_] -> T0
end,
{utc, UTCTime};
true ->
Time
end.
%% ==================================================================