|
|
@ -86,11 +86,11 @@ handle_call(get_loglevel, #state{level=Level} = State) -> |
|
|
handle_call({set_loglevel, Level}, State) -> |
|
|
handle_call({set_loglevel, Level}, State) -> |
|
|
{ok, ok, State#state{level= rumUtil:config_to_mask(Level)}}; |
|
|
{ok, ok, State#state{level= rumUtil:config_to_mask(Level)}}; |
|
|
handle_call(print_state, State) -> |
|
|
handle_call(print_state, State) -> |
|
|
spawn(fun() -> lager:info("State ~p", [lager:pr(State, ?MODULE)]) end), |
|
|
|
|
|
|
|
|
spawn(fun() -> eRum:info("State ~p", [eRum:pr(State, ?MODULE)]) end), |
|
|
timer:sleep(100), |
|
|
timer:sleep(100), |
|
|
{ok, ok, State}; |
|
|
{ok, ok, State}; |
|
|
handle_call(print_bad_state, State) -> |
|
|
handle_call(print_bad_state, State) -> |
|
|
spawn(fun() -> lager:info("State ~p", [lager:pr({state, 1}, ?MODULE)]) end), |
|
|
|
|
|
|
|
|
spawn(fun() -> eRum:info("State ~p", [eRum:pr({state, 1}, ?MODULE)]) end), |
|
|
timer:sleep(100), |
|
|
timer:sleep(100), |
|
|
{ok, ok, State}; |
|
|
{ok, ok, State}; |
|
|
handle_call(_Request, State) -> |
|
|
handle_call(_Request, State) -> |
|
|
@ -170,7 +170,7 @@ print_bad_state(Sink) -> |
|
|
gen_event:call(Sink, ?MODULE, print_bad_state). |
|
|
gen_event:call(Sink, ?MODULE, print_bad_state). |
|
|
|
|
|
|
|
|
not_running_test() -> |
|
|
not_running_test() -> |
|
|
?assertEqual({error, lager_not_running}, lager:log(info, self(), "not running")). |
|
|
|
|
|
|
|
|
?assertEqual({error, lager_not_running}, eRum:log(info, self(), "not running")). |
|
|
|
|
|
|
|
|
lager_test_() -> |
|
|
lager_test_() -> |
|
|
{foreach, |
|
|
{foreach, |
|
|
@ -185,12 +185,12 @@ lager_test_() -> |
|
|
}, |
|
|
}, |
|
|
{"test sink not running", |
|
|
{"test sink not running", |
|
|
fun() -> |
|
|
fun() -> |
|
|
?assertEqual({error, {sink_not_configured, test}}, lager:log(test, info, self(), "~p", "not running")) |
|
|
|
|
|
|
|
|
?assertEqual({error, {sink_not_configured, test}}, eRum:log(test, info, self(), "~p", "not running")) |
|
|
end |
|
|
end |
|
|
}, |
|
|
}, |
|
|
{"logging works", |
|
|
{"logging works", |
|
|
fun() -> |
|
|
fun() -> |
|
|
lager:warning("test message"), |
|
|
|
|
|
|
|
|
eRum:warning("test message"), |
|
|
?assertEqual(1, count()), |
|
|
?assertEqual(1, count()), |
|
|
{Level, _Time, Message, _Metadata} = pop(), |
|
|
{Level, _Time, Message, _Metadata} = pop(), |
|
|
?assertMatch(Level, rumUtil:level_to_num(warning)), |
|
|
?assertMatch(Level, rumUtil:level_to_num(warning)), |
|
|
@ -210,7 +210,7 @@ lager_test_() -> |
|
|
}, |
|
|
}, |
|
|
{"unsafe logging works", |
|
|
{"unsafe logging works", |
|
|
fun() -> |
|
|
fun() -> |
|
|
lager:warning_unsafe("test message"), |
|
|
|
|
|
|
|
|
eRum:warning_unsafe("test message"), |
|
|
?assertEqual(1, count()), |
|
|
?assertEqual(1, count()), |
|
|
{Level, _Time, Message, _Metadata} = pop(), |
|
|
{Level, _Time, Message, _Metadata} = pop(), |
|
|
?assertMatch(Level, rumUtil:level_to_num(warning)), |
|
|
?assertMatch(Level, rumUtil:level_to_num(warning)), |
|
|
@ -220,7 +220,7 @@ lager_test_() -> |
|
|
}, |
|
|
}, |
|
|
{"logging with arguments works", |
|
|
{"logging with arguments works", |
|
|
fun() -> |
|
|
fun() -> |
|
|
lager:warning("test message ~p", [self()]), |
|
|
|
|
|
|
|
|
eRum:warning("test message ~p", [self()]), |
|
|
?assertEqual(1, count()), |
|
|
?assertEqual(1, count()), |
|
|
{Level, _Time, Message,_Metadata} = pop(), |
|
|
{Level, _Time, Message,_Metadata} = pop(), |
|
|
?assertMatch(Level, rumUtil:level_to_num(warning)), |
|
|
?assertMatch(Level, rumUtil:level_to_num(warning)), |
|
|
@ -240,7 +240,7 @@ lager_test_() -> |
|
|
}, |
|
|
}, |
|
|
{"unsafe logging with args works", |
|
|
{"unsafe logging with args works", |
|
|
fun() -> |
|
|
fun() -> |
|
|
lager:warning_unsafe("test message ~p", [self()]), |
|
|
|
|
|
|
|
|
eRum:warning_unsafe("test message ~p", [self()]), |
|
|
?assertEqual(1, count()), |
|
|
?assertEqual(1, count()), |
|
|
{Level, _Time, Message,_Metadata} = pop(), |
|
|
{Level, _Time, Message,_Metadata} = pop(), |
|
|
?assertMatch(Level, rumUtil:level_to_num(warning)), |
|
|
?assertMatch(Level, rumUtil:level_to_num(warning)), |
|
|
@ -252,7 +252,7 @@ lager_test_() -> |
|
|
fun() -> |
|
|
fun() -> |
|
|
?assertEqual(0, count()), |
|
|
?assertEqual(0, count()), |
|
|
begin |
|
|
begin |
|
|
lager:warning("test message 2") |
|
|
|
|
|
|
|
|
eRum:warning("test message 2") |
|
|
end, |
|
|
end, |
|
|
?assertEqual(1, count()), |
|
|
?assertEqual(1, count()), |
|
|
ok |
|
|
ok |
|
|
@ -261,7 +261,7 @@ lager_test_() -> |
|
|
{"logging works from inside a list comprehension", |
|
|
{"logging works from inside a list comprehension", |
|
|
fun() -> |
|
|
fun() -> |
|
|
?assertEqual(0, count()), |
|
|
?assertEqual(0, count()), |
|
|
[lager:warning("test message") || _N <- lists:seq(1, 10)], |
|
|
|
|
|
|
|
|
[eRum:warning("test message") || _N <- lists:seq(1, 10)], |
|
|
?assertEqual(10, count()), |
|
|
?assertEqual(10, count()), |
|
|
ok |
|
|
ok |
|
|
end |
|
|
end |
|
|
@ -269,7 +269,7 @@ lager_test_() -> |
|
|
{"logging works from a begin/end block inside a list comprehension", |
|
|
{"logging works from a begin/end block inside a list comprehension", |
|
|
fun() -> |
|
|
fun() -> |
|
|
?assertEqual(0, count()), |
|
|
?assertEqual(0, count()), |
|
|
[ begin lager:warning("test message") end || _N <- lists:seq(1, 10)], |
|
|
|
|
|
|
|
|
[ begin eRum:warning("test message") end || _N <- lists:seq(1, 10)], |
|
|
?assertEqual(10, count()), |
|
|
?assertEqual(10, count()), |
|
|
ok |
|
|
ok |
|
|
end |
|
|
end |
|
|
@ -277,7 +277,7 @@ lager_test_() -> |
|
|
{"logging works from a nested list comprehension", |
|
|
{"logging works from a nested list comprehension", |
|
|
fun() -> |
|
|
fun() -> |
|
|
?assertEqual(0, count()), |
|
|
?assertEqual(0, count()), |
|
|
[ [lager:warning("test message") || _N <- lists:seq(1, 10)] || |
|
|
|
|
|
|
|
|
[ [eRum:warning("test message") || _N <- lists:seq(1, 10)] || |
|
|
_I <- lists:seq(1, 10)], |
|
|
_I <- lists:seq(1, 10)], |
|
|
?assertEqual(100, count()), |
|
|
?assertEqual(100, count()), |
|
|
ok |
|
|
ok |
|
|
@ -286,8 +286,8 @@ lager_test_() -> |
|
|
{"logging with only metadata works", |
|
|
{"logging with only metadata works", |
|
|
fun() -> |
|
|
fun() -> |
|
|
?assertEqual(0, count()), |
|
|
?assertEqual(0, count()), |
|
|
lager:warning([{just, metadata}]), |
|
|
|
|
|
lager:warning([{just, metadata}, {foo, bar}]), |
|
|
|
|
|
|
|
|
eRum:warning([{just, metadata}]), |
|
|
|
|
|
eRum:warning([{just, metadata}, {foo, bar}]), |
|
|
?assertEqual(2, count()), |
|
|
?assertEqual(2, count()), |
|
|
ok |
|
|
ok |
|
|
end |
|
|
end |
|
|
@ -298,12 +298,12 @@ lager_test_() -> |
|
|
Attr = [{a, alpha}, {b, beta}], |
|
|
Attr = [{a, alpha}, {b, beta}], |
|
|
Fmt = "format ~p", |
|
|
Fmt = "format ~p", |
|
|
Args = [world], |
|
|
Args = [world], |
|
|
lager:info(Attr, "hello"), |
|
|
|
|
|
lager:info(Attr, "hello ~p", [world]), |
|
|
|
|
|
lager:info(Fmt, [world]), |
|
|
|
|
|
lager:info("hello ~p", Args), |
|
|
|
|
|
lager:info(Attr, "hello ~p", Args), |
|
|
|
|
|
lager:info([{d, delta}, {g, gamma}], Fmt, Args), |
|
|
|
|
|
|
|
|
eRum:info(Attr, "hello"), |
|
|
|
|
|
eRum:info(Attr, "hello ~p", [world]), |
|
|
|
|
|
eRum:info(Fmt, [world]), |
|
|
|
|
|
eRum:info("hello ~p", Args), |
|
|
|
|
|
eRum:info(Attr, "hello ~p", Args), |
|
|
|
|
|
eRum:info([{d, delta}, {g, gamma}], Fmt, Args), |
|
|
?assertEqual(6, count()), |
|
|
?assertEqual(6, count()), |
|
|
{_Level, _Time, Message, Metadata} = pop(), |
|
|
{_Level, _Time, Message, Metadata} = pop(), |
|
|
?assertMatch([{a, alpha}, {b, beta}|_], Metadata), |
|
|
?assertMatch([{a, alpha}, {b, beta}|_], Metadata), |
|
|
@ -328,12 +328,12 @@ lager_test_() -> |
|
|
Attr = [{a, alpha}, {b, beta}], |
|
|
Attr = [{a, alpha}, {b, beta}], |
|
|
Fmt = "format ~p", |
|
|
Fmt = "format ~p", |
|
|
Args = [world], |
|
|
Args = [world], |
|
|
lager:info([{K, atom_to_list(V)} || {K, V} <- Attr], "hello"), |
|
|
|
|
|
lager:info([{K, atom_to_list(V)} || {K, V} <- Attr], "hello ~p", [{atom, X} || X <- Args]), |
|
|
|
|
|
lager:info([X || X <- Fmt], [world]), |
|
|
|
|
|
lager:info("hello ~p", [{atom, X} || X <- Args]), |
|
|
|
|
|
lager:info([{K, atom_to_list(V)} || {K, V} <- Attr], "hello ~p", [{atom, X} || X <- Args]), |
|
|
|
|
|
lager:info([{d, delta}, {g, gamma}], Fmt, [{atom, X} || X <- Args]), |
|
|
|
|
|
|
|
|
eRum:info([{K, atom_to_list(V)} || {K, V} <- Attr], "hello"), |
|
|
|
|
|
eRum:info([{K, atom_to_list(V)} || {K, V} <- Attr], "hello ~p", [{atom, X} || X <- Args]), |
|
|
|
|
|
eRum:info([X || X <- Fmt], [world]), |
|
|
|
|
|
eRum:info("hello ~p", [{atom, X} || X <- Args]), |
|
|
|
|
|
eRum:info([{K, atom_to_list(V)} || {K, V} <- Attr], "hello ~p", [{atom, X} || X <- Args]), |
|
|
|
|
|
eRum:info([{d, delta}, {g, gamma}], Fmt, [{atom, X} || X <- Args]), |
|
|
?assertEqual(6, count()), |
|
|
?assertEqual(6, count()), |
|
|
{_Level, _Time, Message, Metadata} = pop(), |
|
|
{_Level, _Time, Message, Metadata} = pop(), |
|
|
?assertMatch([{a, "alpha"}, {b, "beta"}|_], Metadata), |
|
|
?assertMatch([{a, "alpha"}, {b, "beta"}|_], Metadata), |
|
|
@ -358,12 +358,12 @@ lager_test_() -> |
|
|
put(attrs, [{a, alpha}, {b, beta}]), |
|
|
put(attrs, [{a, alpha}, {b, beta}]), |
|
|
put(format, "format ~p"), |
|
|
put(format, "format ~p"), |
|
|
put(args, [world]), |
|
|
put(args, [world]), |
|
|
lager:info(get(attrs), "hello"), |
|
|
|
|
|
lager:info(get(attrs), "hello ~p", get(args)), |
|
|
|
|
|
lager:info(get(format), [world]), |
|
|
|
|
|
lager:info("hello ~p", erlang:get(args)), |
|
|
|
|
|
lager:info(fun() -> get(attrs) end(), "hello ~p", get(args)), |
|
|
|
|
|
lager:info([{d, delta}, {g, gamma}], get(format), get(args)), |
|
|
|
|
|
|
|
|
eRum:info(get(attrs), "hello"), |
|
|
|
|
|
eRum:info(get(attrs), "hello ~p", get(args)), |
|
|
|
|
|
eRum:info(get(format), [world]), |
|
|
|
|
|
eRum:info("hello ~p", erlang:get(args)), |
|
|
|
|
|
eRum:info(fun() -> get(attrs) end(), "hello ~p", get(args)), |
|
|
|
|
|
eRum:info([{d, delta}, {g, gamma}], get(format), get(args)), |
|
|
?assertEqual(6, count()), |
|
|
?assertEqual(6, count()), |
|
|
{_Level, _Time, Message, Metadata} = pop(), |
|
|
{_Level, _Time, Message, Metadata} = pop(), |
|
|
?assertMatch([{a, alpha}, {b, beta}|_], Metadata), |
|
|
?assertMatch([{a, alpha}, {b, beta}|_], Metadata), |
|
|
@ -386,12 +386,12 @@ lager_test_() -> |
|
|
fun() -> |
|
|
fun() -> |
|
|
?assertEqual(0, count()), |
|
|
?assertEqual(0, count()), |
|
|
Test = #test{attrs=[{a, alpha}, {b, beta}], format="format ~p", args=[world]}, |
|
|
Test = #test{attrs=[{a, alpha}, {b, beta}], format="format ~p", args=[world]}, |
|
|
lager:info(Test#test.attrs, "hello"), |
|
|
|
|
|
lager:info(Test#test.attrs, "hello ~p", Test#test.args), |
|
|
|
|
|
lager:info(Test#test.format, [world]), |
|
|
|
|
|
lager:info("hello ~p", Test#test.args), |
|
|
|
|
|
lager:info(Test#test.attrs, "hello ~p", Test#test.args), |
|
|
|
|
|
lager:info([{d, delta}, {g, gamma}], Test#test.format, Test#test.args), |
|
|
|
|
|
|
|
|
eRum:info(Test#test.attrs, "hello"), |
|
|
|
|
|
eRum:info(Test#test.attrs, "hello ~p", Test#test.args), |
|
|
|
|
|
eRum:info(Test#test.format, [world]), |
|
|
|
|
|
eRum:info("hello ~p", Test#test.args), |
|
|
|
|
|
eRum:info(Test#test.attrs, "hello ~p", Test#test.args), |
|
|
|
|
|
eRum:info([{d, delta}, {g, gamma}], Test#test.format, Test#test.args), |
|
|
?assertEqual(6, count()), |
|
|
?assertEqual(6, count()), |
|
|
{_Level, _Time, Message, Metadata} = pop(), |
|
|
{_Level, _Time, Message, Metadata} = pop(), |
|
|
?assertMatch([{a, alpha}, {b, beta}|_], Metadata), |
|
|
?assertMatch([{a, alpha}, {b, beta}|_], Metadata), |
|
|
@ -414,159 +414,159 @@ lager_test_() -> |
|
|
{"log messages below the threshold are ignored", |
|
|
{"log messages below the threshold are ignored", |
|
|
fun() -> |
|
|
fun() -> |
|
|
?assertEqual(0, count()), |
|
|
?assertEqual(0, count()), |
|
|
lager:debug("this message will be ignored"), |
|
|
|
|
|
|
|
|
eRum:debug("this message will be ignored"), |
|
|
?assertEqual(0, count()), |
|
|
?assertEqual(0, count()), |
|
|
?assertEqual(0, count_ignored()), |
|
|
?assertEqual(0, count_ignored()), |
|
|
lager_config:set(loglevel, {element(2, rumUtil:config_to_mask(debug)), []}), |
|
|
lager_config:set(loglevel, {element(2, rumUtil:config_to_mask(debug)), []}), |
|
|
lager:debug("this message should be ignored"), |
|
|
|
|
|
|
|
|
eRum:debug("this message should be ignored"), |
|
|
?assertEqual(0, count()), |
|
|
?assertEqual(0, count()), |
|
|
?assertEqual(1, count_ignored()), |
|
|
?assertEqual(1, count_ignored()), |
|
|
lager:set_loglevel(?MODULE, debug), |
|
|
|
|
|
|
|
|
eRum:set_loglevel(?MODULE, debug), |
|
|
?assertEqual({?DEBUG bor ?INFO bor ?NOTICE bor ?WARNING bor ?ERROR bor ?CRITICAL bor ?ALERT bor ?EMERGENCY, []}, lager_config:get(loglevel)), |
|
|
?assertEqual({?DEBUG bor ?INFO bor ?NOTICE bor ?WARNING bor ?ERROR bor ?CRITICAL bor ?ALERT bor ?EMERGENCY, []}, lager_config:get(loglevel)), |
|
|
lager:debug("this message should be logged"), |
|
|
|
|
|
|
|
|
eRum:debug("this message should be logged"), |
|
|
?assertEqual(1, count()), |
|
|
?assertEqual(1, count()), |
|
|
?assertEqual(1, count_ignored()), |
|
|
?assertEqual(1, count_ignored()), |
|
|
?assertEqual(debug, lager:get_loglevel(?MODULE)), |
|
|
|
|
|
|
|
|
?assertEqual(debug, eRum:get_loglevel(?MODULE)), |
|
|
ok |
|
|
ok |
|
|
end |
|
|
end |
|
|
}, |
|
|
}, |
|
|
{"tracing works", |
|
|
{"tracing works", |
|
|
fun() -> |
|
|
fun() -> |
|
|
lager_config:set(loglevel, {element(2, rumUtil:config_to_mask(error)), []}), |
|
|
lager_config:set(loglevel, {element(2, rumUtil:config_to_mask(error)), []}), |
|
|
ok = lager:info("hello world"), |
|
|
|
|
|
|
|
|
ok = eRum:info("hello world"), |
|
|
?assertEqual(0, count()), |
|
|
?assertEqual(0, count()), |
|
|
lager:trace(?MODULE, [{module, ?MODULE}], debug), |
|
|
|
|
|
|
|
|
eRum:trace(?MODULE, [{module, ?MODULE}], debug), |
|
|
?assertMatch({?ERROR bor ?CRITICAL bor ?ALERT bor ?EMERGENCY, _}, lager_config:get(loglevel)), |
|
|
?assertMatch({?ERROR bor ?CRITICAL bor ?ALERT bor ?EMERGENCY, _}, lager_config:get(loglevel)), |
|
|
%% elegible for tracing |
|
|
%% elegible for tracing |
|
|
ok = lager:info("hello world"), |
|
|
|
|
|
|
|
|
ok = eRum:info("hello world"), |
|
|
%% NOT elegible for tracing |
|
|
%% NOT elegible for tracing |
|
|
ok = lager:log(info, [{pid, self()}], "hello world"), |
|
|
|
|
|
|
|
|
ok = eRum:log(info, [{pid, self()}], "hello world"), |
|
|
?assertEqual(1, count()), |
|
|
?assertEqual(1, count()), |
|
|
ok |
|
|
ok |
|
|
end |
|
|
end |
|
|
}, |
|
|
}, |
|
|
{"tracing works with custom attributes", |
|
|
{"tracing works with custom attributes", |
|
|
fun() -> |
|
|
fun() -> |
|
|
lager:set_loglevel(?MODULE, error), |
|
|
|
|
|
|
|
|
eRum:set_loglevel(?MODULE, error), |
|
|
?assertEqual({?ERROR bor ?CRITICAL bor ?ALERT bor ?EMERGENCY, []}, lager_config:get(loglevel)), |
|
|
?assertEqual({?ERROR bor ?CRITICAL bor ?ALERT bor ?EMERGENCY, []}, lager_config:get(loglevel)), |
|
|
lager_config:set(loglevel, {element(2, rumUtil:config_to_mask(error)), []}), |
|
|
lager_config:set(loglevel, {element(2, rumUtil:config_to_mask(error)), []}), |
|
|
lager:info([{requestid, 6}], "hello world"), |
|
|
|
|
|
|
|
|
eRum:info([{requestid, 6}], "hello world"), |
|
|
?assertEqual(0, count()), |
|
|
?assertEqual(0, count()), |
|
|
lager:trace(?MODULE, [{requestid, 6}, {foo, bar}], debug), |
|
|
|
|
|
lager:info([{requestid, 6}, {foo, bar}], "hello world"), |
|
|
|
|
|
|
|
|
eRum:trace(?MODULE, [{requestid, 6}, {foo, bar}], debug), |
|
|
|
|
|
eRum:info([{requestid, 6}, {foo, bar}], "hello world"), |
|
|
?assertEqual(1, count()), |
|
|
?assertEqual(1, count()), |
|
|
lager:trace(?MODULE, [{requestid, '*'}], debug), |
|
|
|
|
|
lager:info([{requestid, 6}], "hello world"), |
|
|
|
|
|
|
|
|
eRum:trace(?MODULE, [{requestid, '*'}], debug), |
|
|
|
|
|
eRum:info([{requestid, 6}], "hello world"), |
|
|
?assertEqual(2, count()), |
|
|
?assertEqual(2, count()), |
|
|
lager:clear_all_traces(), |
|
|
|
|
|
lager:info([{requestid, 6}], "hello world"), |
|
|
|
|
|
|
|
|
eRum:clear_all_traces(), |
|
|
|
|
|
eRum:info([{requestid, 6}], "hello world"), |
|
|
?assertEqual(2, count()), |
|
|
?assertEqual(2, count()), |
|
|
ok |
|
|
ok |
|
|
end |
|
|
end |
|
|
}, |
|
|
}, |
|
|
{"tracing works with custom attributes and event stream processing", |
|
|
{"tracing works with custom attributes and event stream processing", |
|
|
fun() -> |
|
|
fun() -> |
|
|
lager:set_loglevel(?MODULE, error), |
|
|
|
|
|
|
|
|
eRum:set_loglevel(?MODULE, error), |
|
|
?assertEqual({?ERROR bor ?CRITICAL bor ?ALERT bor ?EMERGENCY, []}, lager_config:get(loglevel)), |
|
|
?assertEqual({?ERROR bor ?CRITICAL bor ?ALERT bor ?EMERGENCY, []}, lager_config:get(loglevel)), |
|
|
lager_config:set(loglevel, {element(2, rumUtil:config_to_mask(error)), []}), |
|
|
lager_config:set(loglevel, {element(2, rumUtil:config_to_mask(error)), []}), |
|
|
lager:info([{requestid, 6}], "hello world"), |
|
|
|
|
|
|
|
|
eRum:info([{requestid, 6}], "hello world"), |
|
|
?assertEqual(0, count()), |
|
|
?assertEqual(0, count()), |
|
|
lager:trace(?MODULE, [{requestid, '>', 5}, {requestid, '<', 7}, {foo, bar}], debug), |
|
|
|
|
|
lager:info([{requestid, 5}, {foo, bar}], "hello world"), |
|
|
|
|
|
lager:info([{requestid, 6}, {foo, bar}], "hello world"), |
|
|
|
|
|
|
|
|
eRum:trace(?MODULE, [{requestid, '>', 5}, {requestid, '<', 7}, {foo, bar}], debug), |
|
|
|
|
|
eRum:info([{requestid, 5}, {foo, bar}], "hello world"), |
|
|
|
|
|
eRum:info([{requestid, 6}, {foo, bar}], "hello world"), |
|
|
?assertEqual(1, count()), |
|
|
?assertEqual(1, count()), |
|
|
lager:clear_all_traces(), |
|
|
|
|
|
lager:trace(?MODULE, [{requestid, '>', 8}, {foo, bar}]), |
|
|
|
|
|
lager:info([{foo, bar}], "hello world"), |
|
|
|
|
|
lager:info([{requestid, 6}], "hello world"), |
|
|
|
|
|
lager:info([{requestid, 7}], "hello world"), |
|
|
|
|
|
lager:info([{requestid, 8}], "hello world"), |
|
|
|
|
|
lager:info([{requestid, 9}, {foo, bar}], "hello world"), |
|
|
|
|
|
lager:info([{requestid, 10}], "hello world"), |
|
|
|
|
|
|
|
|
eRum:clear_all_traces(), |
|
|
|
|
|
eRum:trace(?MODULE, [{requestid, '>', 8}, {foo, bar}]), |
|
|
|
|
|
eRum:info([{foo, bar}], "hello world"), |
|
|
|
|
|
eRum:info([{requestid, 6}], "hello world"), |
|
|
|
|
|
eRum:info([{requestid, 7}], "hello world"), |
|
|
|
|
|
eRum:info([{requestid, 8}], "hello world"), |
|
|
|
|
|
eRum:info([{requestid, 9}, {foo, bar}], "hello world"), |
|
|
|
|
|
eRum:info([{requestid, 10}], "hello world"), |
|
|
?assertEqual(2, count()), |
|
|
?assertEqual(2, count()), |
|
|
lager:trace(?MODULE, [{requestid, '>', 8}]), |
|
|
|
|
|
lager:info([{foo, bar}], "hello world"), |
|
|
|
|
|
lager:info([{requestid, 6}], "hello world"), |
|
|
|
|
|
lager:info([{requestid, 7}], "hello world"), |
|
|
|
|
|
lager:info([{requestid, 8}], "hello world"), |
|
|
|
|
|
lager:info([{requestid, 9}, {foo, bar}], "hello world"), |
|
|
|
|
|
lager:info([{requestid, 10}], "hello world"), |
|
|
|
|
|
|
|
|
eRum:trace(?MODULE, [{requestid, '>', 8}]), |
|
|
|
|
|
eRum:info([{foo, bar}], "hello world"), |
|
|
|
|
|
eRum:info([{requestid, 6}], "hello world"), |
|
|
|
|
|
eRum:info([{requestid, 7}], "hello world"), |
|
|
|
|
|
eRum:info([{requestid, 8}], "hello world"), |
|
|
|
|
|
eRum:info([{requestid, 9}, {foo, bar}], "hello world"), |
|
|
|
|
|
eRum:info([{requestid, 10}], "hello world"), |
|
|
?assertEqual(4, count()), |
|
|
?assertEqual(4, count()), |
|
|
lager:trace(?MODULE, [{foo, '=', bar}]), |
|
|
|
|
|
lager:info([{foo, bar}], "hello world"), |
|
|
|
|
|
lager:info([{requestid, 6}], "hello world"), |
|
|
|
|
|
lager:info([{requestid, 7}], "hello world"), |
|
|
|
|
|
lager:info([{requestid, 8}], "hello world"), |
|
|
|
|
|
lager:info([{requestid, 9}, {foo, bar}], "hello world"), |
|
|
|
|
|
lager:info([{requestid, 10}], "hello world"), |
|
|
|
|
|
lager:trace(?MODULE, [{fu, '!'}]), |
|
|
|
|
|
lager:info([{foo, bar}], "hello world"), |
|
|
|
|
|
lager:info([{ooh, car}], "hello world"), |
|
|
|
|
|
lager:info([{fu, bar}], "hello world"), |
|
|
|
|
|
lager:trace(?MODULE, [{fu, '*'}]), |
|
|
|
|
|
lager:info([{fu, bar}], "hello world"), |
|
|
|
|
|
|
|
|
eRum:trace(?MODULE, [{foo, '=', bar}]), |
|
|
|
|
|
eRum:info([{foo, bar}], "hello world"), |
|
|
|
|
|
eRum:info([{requestid, 6}], "hello world"), |
|
|
|
|
|
eRum:info([{requestid, 7}], "hello world"), |
|
|
|
|
|
eRum:info([{requestid, 8}], "hello world"), |
|
|
|
|
|
eRum:info([{requestid, 9}, {foo, bar}], "hello world"), |
|
|
|
|
|
eRum:info([{requestid, 10}], "hello world"), |
|
|
|
|
|
eRum:trace(?MODULE, [{fu, '!'}]), |
|
|
|
|
|
eRum:info([{foo, bar}], "hello world"), |
|
|
|
|
|
eRum:info([{ooh, car}], "hello world"), |
|
|
|
|
|
eRum:info([{fu, bar}], "hello world"), |
|
|
|
|
|
eRum:trace(?MODULE, [{fu, '*'}]), |
|
|
|
|
|
eRum:info([{fu, bar}], "hello world"), |
|
|
?assertEqual(10, count()), |
|
|
?assertEqual(10, count()), |
|
|
lager:clear_all_traces(), |
|
|
|
|
|
lager:info([{requestid, 6}], "hello world"), |
|
|
|
|
|
|
|
|
eRum:clear_all_traces(), |
|
|
|
|
|
eRum:info([{requestid, 6}], "hello world"), |
|
|
?assertEqual(10, count()), |
|
|
?assertEqual(10, count()), |
|
|
lager:clear_all_traces(), |
|
|
|
|
|
lager:trace(?MODULE, [{requestid, '>=', 5}, {requestid, '=<', 7}], debug), |
|
|
|
|
|
lager:info([{requestid, 4}], "nope!"), |
|
|
|
|
|
lager:info([{requestid, 5}], "hello world"), |
|
|
|
|
|
lager:info([{requestid, 7}], "hello world again"), |
|
|
|
|
|
|
|
|
eRum:clear_all_traces(), |
|
|
|
|
|
eRum:trace(?MODULE, [{requestid, '>=', 5}, {requestid, '=<', 7}], debug), |
|
|
|
|
|
eRum:info([{requestid, 4}], "nope!"), |
|
|
|
|
|
eRum:info([{requestid, 5}], "hello world"), |
|
|
|
|
|
eRum:info([{requestid, 7}], "hello world again"), |
|
|
?assertEqual(12, count()), |
|
|
?assertEqual(12, count()), |
|
|
lager:clear_all_traces(), |
|
|
|
|
|
lager:trace(?MODULE, [{foo, '!=', bar}]), |
|
|
|
|
|
lager:info([{foo, bar}], "hello world"), |
|
|
|
|
|
|
|
|
eRum:clear_all_traces(), |
|
|
|
|
|
eRum:trace(?MODULE, [{foo, '!=', bar}]), |
|
|
|
|
|
eRum:info([{foo, bar}], "hello world"), |
|
|
?assertEqual(12, count()), |
|
|
?assertEqual(12, count()), |
|
|
lager:info([{foo, baz}], "blarg"), |
|
|
|
|
|
|
|
|
eRum:info([{foo, baz}], "blarg"), |
|
|
?assertEqual(13, count()), |
|
|
?assertEqual(13, count()), |
|
|
lager:clear_all_traces(), |
|
|
|
|
|
lager:trace(?MODULE, [{all, [{foo, '=', bar}, {null, false}]}]), |
|
|
|
|
|
lager:info([{foo, bar}], "should not be logged"), |
|
|
|
|
|
|
|
|
eRum:clear_all_traces(), |
|
|
|
|
|
eRum:trace(?MODULE, [{all, [{foo, '=', bar}, {null, false}]}]), |
|
|
|
|
|
eRum:info([{foo, bar}], "should not be logged"), |
|
|
?assertEqual(13, count()), |
|
|
?assertEqual(13, count()), |
|
|
lager:clear_all_traces(), |
|
|
|
|
|
lager:trace(?MODULE, [{any, [{foo, '=', bar}, {null, true}]}]), |
|
|
|
|
|
lager:info([{foo, qux}], "should be logged"), |
|
|
|
|
|
|
|
|
eRum:clear_all_traces(), |
|
|
|
|
|
eRum:trace(?MODULE, [{any, [{foo, '=', bar}, {null, true}]}]), |
|
|
|
|
|
eRum:info([{foo, qux}], "should be logged"), |
|
|
?assertEqual(14, count()), |
|
|
?assertEqual(14, count()), |
|
|
ok |
|
|
ok |
|
|
end |
|
|
end |
|
|
}, |
|
|
}, |
|
|
{"tracing custom attributes works with event stream processing statistics and reductions", |
|
|
{"tracing custom attributes works with event stream processing statistics and reductions", |
|
|
fun() -> |
|
|
fun() -> |
|
|
lager:set_loglevel(?MODULE, error), |
|
|
|
|
|
|
|
|
eRum:set_loglevel(?MODULE, error), |
|
|
?assertEqual({?ERROR bor ?CRITICAL bor ?ALERT bor ?EMERGENCY, []}, lager_config:get(loglevel)), |
|
|
?assertEqual({?ERROR bor ?CRITICAL bor ?ALERT bor ?EMERGENCY, []}, lager_config:get(loglevel)), |
|
|
lager_config:set(loglevel, {element(2, rumUtil:config_to_mask(error)), []}), |
|
|
lager_config:set(loglevel, {element(2, rumUtil:config_to_mask(error)), []}), |
|
|
lager:info([{requestid, 6}], "hello world"), |
|
|
|
|
|
|
|
|
eRum:info([{requestid, 6}], "hello world"), |
|
|
?assertEqual(0, count()), |
|
|
?assertEqual(0, count()), |
|
|
lager:trace(?MODULE, [{beta, '*'}]), |
|
|
|
|
|
lager:trace(?MODULE, [{meta, "data"}]), |
|
|
|
|
|
lager:info([{meta, "data"}], "hello world"), |
|
|
|
|
|
lager:info([{beta, 2}], "hello world"), |
|
|
|
|
|
lager:info([{beta, 2.1}, {foo, bar}], "hello world"), |
|
|
|
|
|
lager:info([{meta, <<"data">>}], "hello world"), |
|
|
|
|
|
|
|
|
eRum:trace(?MODULE, [{beta, '*'}]), |
|
|
|
|
|
eRum:trace(?MODULE, [{meta, "data"}]), |
|
|
|
|
|
eRum:info([{meta, "data"}], "hello world"), |
|
|
|
|
|
eRum:info([{beta, 2}], "hello world"), |
|
|
|
|
|
eRum:info([{beta, 2.1}, {foo, bar}], "hello world"), |
|
|
|
|
|
eRum:info([{meta, <<"data">>}], "hello world"), |
|
|
?assertEqual(8, ?RumDefTracer:info(input)), |
|
|
?assertEqual(8, ?RumDefTracer:info(input)), |
|
|
?assertEqual(6, ?RumDefTracer:info(output)), |
|
|
?assertEqual(6, ?RumDefTracer:info(output)), |
|
|
?assertEqual(2, ?RumDefTracer:info(filter)), |
|
|
?assertEqual(2, ?RumDefTracer:info(filter)), |
|
|
lager:clear_all_traces(), |
|
|
|
|
|
lager:trace(?MODULE, [{meta, "data"}]), |
|
|
|
|
|
lager:trace(?MODULE, [{beta, '>', 2}, {beta, '<', 2.12}]), |
|
|
|
|
|
lager:info([{meta, "data"}], "hello world"), |
|
|
|
|
|
lager:info([{beta, 2}], "hello world"), |
|
|
|
|
|
lager:info([{beta, 2.1}, {foo, bar}], "hello world"), |
|
|
|
|
|
lager:info([{meta, <<"data">>}], "hello world"), |
|
|
|
|
|
|
|
|
eRum:clear_all_traces(), |
|
|
|
|
|
eRum:trace(?MODULE, [{meta, "data"}]), |
|
|
|
|
|
eRum:trace(?MODULE, [{beta, '>', 2}, {beta, '<', 2.12}]), |
|
|
|
|
|
eRum:info([{meta, "data"}], "hello world"), |
|
|
|
|
|
eRum:info([{beta, 2}], "hello world"), |
|
|
|
|
|
eRum:info([{beta, 2.1}, {foo, bar}], "hello world"), |
|
|
|
|
|
eRum:info([{meta, <<"data">>}], "hello world"), |
|
|
?assertEqual(8, ?RumDefTracer:info(input)), |
|
|
?assertEqual(8, ?RumDefTracer:info(input)), |
|
|
?assertEqual(4, ?RumDefTracer:info(output)), |
|
|
?assertEqual(4, ?RumDefTracer:info(output)), |
|
|
?assertEqual(4, ?RumDefTracer:info(filter)), |
|
|
?assertEqual(4, ?RumDefTracer:info(filter)), |
|
|
lager:clear_all_traces(), |
|
|
|
|
|
lager:trace_console([{beta, '>', 2}, {meta, "data"}]), |
|
|
|
|
|
lager:trace_console([{beta, '>', 2}, {beta, '<', 2.12}]), |
|
|
|
|
|
|
|
|
eRum:clear_all_traces(), |
|
|
|
|
|
eRum:trace_console([{beta, '>', 2}, {meta, "data"}]), |
|
|
|
|
|
eRum:trace_console([{beta, '>', 2}, {beta, '<', 2.12}]), |
|
|
Reduced = {all, [{any, [{beta, '<', 2.12}, {meta, '=', "data"}]}, |
|
|
Reduced = {all, [{any, [{beta, '<', 2.12}, {meta, '=', "data"}]}, |
|
|
{beta, '>', 2}]}, |
|
|
{beta, '>', 2}]}, |
|
|
?assertEqual(Reduced, ?RumDefTracer:info('query')), |
|
|
?assertEqual(Reduced, ?RumDefTracer:info('query')), |
|
|
|
|
|
|
|
|
lager:clear_all_traces(), |
|
|
|
|
|
lager:info([{requestid, 6}], "hello world"), |
|
|
|
|
|
|
|
|
eRum:clear_all_traces(), |
|
|
|
|
|
eRum:info([{requestid, 6}], "hello world"), |
|
|
?assertEqual(5, count()), |
|
|
?assertEqual(5, count()), |
|
|
ok |
|
|
ok |
|
|
end |
|
|
end |
|
|
@ -574,14 +574,14 @@ lager_test_() -> |
|
|
{"persistent traces work", |
|
|
{"persistent traces work", |
|
|
fun() -> |
|
|
fun() -> |
|
|
?assertEqual(0, count()), |
|
|
?assertEqual(0, count()), |
|
|
lager:debug([{foo, bar}], "hello world"), |
|
|
|
|
|
|
|
|
eRum:debug([{foo, bar}], "hello world"), |
|
|
?assertEqual(0, count()), |
|
|
?assertEqual(0, count()), |
|
|
application:stop(lager), |
|
|
application:stop(lager), |
|
|
application:set_env(lager, traces, [{lager_test_backend, [{foo, bar}], debug}]), |
|
|
application:set_env(lager, traces, [{lager_test_backend, [{foo, bar}], debug}]), |
|
|
lager:start(), |
|
|
|
|
|
|
|
|
eRum:start(), |
|
|
timer:sleep(5), |
|
|
timer:sleep(5), |
|
|
flush(), |
|
|
flush(), |
|
|
lager:debug([{foo, bar}], "hello world"), |
|
|
|
|
|
|
|
|
eRum:debug([{foo, bar}], "hello world"), |
|
|
?assertEqual(1, count()), |
|
|
?assertEqual(1, count()), |
|
|
application:unset_env(lager, traces), |
|
|
application:unset_env(lager, traces), |
|
|
ok |
|
|
ok |
|
|
@ -589,15 +589,15 @@ lager_test_() -> |
|
|
}, |
|
|
}, |
|
|
{"tracing honors loglevel", |
|
|
{"tracing honors loglevel", |
|
|
fun() -> |
|
|
fun() -> |
|
|
lager:set_loglevel(?MODULE, error), |
|
|
|
|
|
|
|
|
eRum:set_loglevel(?MODULE, error), |
|
|
?assertEqual({?ERROR bor ?CRITICAL bor ?ALERT bor ?EMERGENCY, []}, lager_config:get(loglevel)), |
|
|
?assertEqual({?ERROR bor ?CRITICAL bor ?ALERT bor ?EMERGENCY, []}, lager_config:get(loglevel)), |
|
|
{ok, T} = lager:trace(?MODULE, [{module, ?MODULE}], notice), |
|
|
|
|
|
ok = lager:info("hello world"), |
|
|
|
|
|
|
|
|
{ok, T} = eRum:trace(?MODULE, [{module, ?MODULE}], notice), |
|
|
|
|
|
ok = eRum:info("hello world"), |
|
|
?assertEqual(0, count()), |
|
|
?assertEqual(0, count()), |
|
|
ok = lager:notice("hello world"), |
|
|
|
|
|
|
|
|
ok = eRum:notice("hello world"), |
|
|
?assertEqual(1, count()), |
|
|
?assertEqual(1, count()), |
|
|
lager:stop_trace(T), |
|
|
|
|
|
ok = lager:notice("hello world"), |
|
|
|
|
|
|
|
|
eRum:stop_trace(T), |
|
|
|
|
|
ok = eRum:notice("hello world"), |
|
|
?assertEqual(1, count()), |
|
|
?assertEqual(1, count()), |
|
|
ok |
|
|
ok |
|
|
end |
|
|
end |
|
|
@ -610,23 +610,23 @@ lager_test_() -> |
|
|
{_, T0} = lager_config:get({Sink, loglevel}), |
|
|
{_, T0} = lager_config:get({Sink, loglevel}), |
|
|
StartGlobal = lager_config:global_get(handlers), |
|
|
StartGlobal = lager_config:global_get(handlers), |
|
|
?assertEqual([], T0), |
|
|
?assertEqual([], T0), |
|
|
{ok, TestTrace1} = lager:trace_file("/tmp/test", [{a, b}]), |
|
|
|
|
|
|
|
|
{ok, TestTrace1} = eRum:trace_file("/tmp/test", [{a, b}]), |
|
|
MidHandlers = gen_event:which_handlers(Sink), |
|
|
MidHandlers = gen_event:which_handlers(Sink), |
|
|
{ok, TestTrace2} = lager:trace_file("/tmp/test", [{c, d}]), |
|
|
|
|
|
|
|
|
{ok, TestTrace2} = eRum:trace_file("/tmp/test", [{c, d}]), |
|
|
MidHandlers = gen_event:which_handlers(Sink), |
|
|
MidHandlers = gen_event:which_handlers(Sink), |
|
|
?assertEqual(length(StartHandlers) + 1, length(MidHandlers)), |
|
|
?assertEqual(length(StartHandlers) + 1, length(MidHandlers)), |
|
|
MidGlobal = lager_config:global_get(handlers), |
|
|
MidGlobal = lager_config:global_get(handlers), |
|
|
?assertEqual(length(StartGlobal)+1, length(MidGlobal)), |
|
|
?assertEqual(length(StartGlobal)+1, length(MidGlobal)), |
|
|
{_, T1} = lager_config:get({Sink, loglevel}), |
|
|
{_, T1} = lager_config:get({Sink, loglevel}), |
|
|
?assertEqual(2, length(T1)), |
|
|
?assertEqual(2, length(T1)), |
|
|
ok = lager:stop_trace(TestTrace1), |
|
|
|
|
|
|
|
|
ok = eRum:stop_trace(TestTrace1), |
|
|
{_, T2} = lager_config:get({Sink, loglevel}), |
|
|
{_, T2} = lager_config:get({Sink, loglevel}), |
|
|
?assertEqual(1, length(T2)), |
|
|
?assertEqual(1, length(T2)), |
|
|
?assertEqual(length(StartHandlers)+1, length( |
|
|
?assertEqual(length(StartHandlers)+1, length( |
|
|
gen_event:which_handlers(Sink))), |
|
|
gen_event:which_handlers(Sink))), |
|
|
|
|
|
|
|
|
?assertEqual(length(StartGlobal)+1, length(lager_config:global_get(handlers))), |
|
|
?assertEqual(length(StartGlobal)+1, length(lager_config:global_get(handlers))), |
|
|
ok = lager:stop_trace(TestTrace2), |
|
|
|
|
|
|
|
|
ok = eRum:stop_trace(TestTrace2), |
|
|
EndHandlers = gen_event:which_handlers(Sink), |
|
|
EndHandlers = gen_event:which_handlers(Sink), |
|
|
EndGlobal = lager_config:global_get(handlers), |
|
|
EndGlobal = lager_config:global_get(handlers), |
|
|
{_, T3} = lager_config:get({Sink, loglevel}), |
|
|
{_, T3} = lager_config:get({Sink, loglevel}), |
|
|
@ -657,7 +657,7 @@ lager_test_() -> |
|
|
}, |
|
|
}, |
|
|
{"record printing fails gracefully when no lager_record attribute", |
|
|
{"record printing fails gracefully when no lager_record attribute", |
|
|
fun() -> |
|
|
fun() -> |
|
|
spawn(fun() -> lager:info("State ~p", [lager:pr({state, 1}, lager)]) end), |
|
|
|
|
|
|
|
|
spawn(fun() -> eRum:info("State ~p", [eRum:pr({state, 1}, lager)]) end), |
|
|
timer:sleep(100), |
|
|
timer:sleep(100), |
|
|
{Level, _Time, Message, _Metadata} = pop(), |
|
|
{Level, _Time, Message, _Metadata} = pop(), |
|
|
?assertMatch(Level, rumUtil:level_to_num(info)), |
|
|
?assertMatch(Level, rumUtil:level_to_num(info)), |
|
|
@ -667,7 +667,7 @@ lager_test_() -> |
|
|
}, |
|
|
}, |
|
|
{"record printing fails gracefully when input is not a tuple", |
|
|
{"record printing fails gracefully when input is not a tuple", |
|
|
fun() -> |
|
|
fun() -> |
|
|
spawn(fun() -> lager:info("State ~p", [lager:pr(ok, lager)]) end), |
|
|
|
|
|
|
|
|
spawn(fun() -> eRum:info("State ~p", [eRum:pr(ok, lager)]) end), |
|
|
timer:sleep(100), |
|
|
timer:sleep(100), |
|
|
{Level, _Time, Message, _Metadata} = pop(), |
|
|
{Level, _Time, Message, _Metadata} = pop(), |
|
|
?assertMatch(Level, rumUtil:level_to_num(info)), |
|
|
?assertMatch(Level, rumUtil:level_to_num(info)), |
|
|
@ -677,7 +677,7 @@ lager_test_() -> |
|
|
}, |
|
|
}, |
|
|
{"record printing fails gracefully when module is invalid", |
|
|
{"record printing fails gracefully when module is invalid", |
|
|
fun() -> |
|
|
fun() -> |
|
|
spawn(fun() -> lager:info("State ~p", [lager:pr({state, 1}, not_a_module)]) end), |
|
|
|
|
|
|
|
|
spawn(fun() -> eRum:info("State ~p", [eRum:pr({state, 1}, not_a_module)]) end), |
|
|
timer:sleep(1000), |
|
|
timer:sleep(1000), |
|
|
{Level, _Time, Message, _Metadata} = pop(), |
|
|
{Level, _Time, Message, _Metadata} = pop(), |
|
|
?assertMatch(Level, rumUtil:level_to_num(info)), |
|
|
?assertMatch(Level, rumUtil:level_to_num(info)), |
|
|
@ -695,15 +695,15 @@ lager_test_() -> |
|
|
}, |
|
|
}, |
|
|
{"metadata in the process dictionary works", |
|
|
{"metadata in the process dictionary works", |
|
|
fun() -> |
|
|
fun() -> |
|
|
lager:md([{platypus, gravid}, {sloth, hirsute}, {duck, erroneous}]), |
|
|
|
|
|
lager:info("I sing the animal kingdom electric!"), |
|
|
|
|
|
|
|
|
eRum:md([{platypus, gravid}, {sloth, hirsute}, {duck, erroneous}]), |
|
|
|
|
|
eRum:info("I sing the animal kingdom electric!"), |
|
|
{_Level, _Time, _Message, Metadata} = pop(), |
|
|
{_Level, _Time, _Message, Metadata} = pop(), |
|
|
?assertEqual(gravid, proplists:get_value(platypus, Metadata)), |
|
|
?assertEqual(gravid, proplists:get_value(platypus, Metadata)), |
|
|
?assertEqual(hirsute, proplists:get_value(sloth, Metadata)), |
|
|
?assertEqual(hirsute, proplists:get_value(sloth, Metadata)), |
|
|
?assertEqual(erroneous, proplists:get_value(duck, Metadata)), |
|
|
?assertEqual(erroneous, proplists:get_value(duck, Metadata)), |
|
|
?assertEqual(undefined, proplists:get_value(eagle, Metadata)), |
|
|
?assertEqual(undefined, proplists:get_value(eagle, Metadata)), |
|
|
lager:md([{platypus, gravid}, {sloth, hirsute}, {eagle, superincumbent}]), |
|
|
|
|
|
lager:info("I sing the animal kingdom dielectric!"), |
|
|
|
|
|
|
|
|
eRum:md([{platypus, gravid}, {sloth, hirsute}, {eagle, superincumbent}]), |
|
|
|
|
|
eRum:info("I sing the animal kingdom dielectric!"), |
|
|
{_Level2, _Time2, _Message2, Metadata2} = pop(), |
|
|
{_Level2, _Time2, _Message2, Metadata2} = pop(), |
|
|
?assertEqual(gravid, proplists:get_value(platypus, Metadata2)), |
|
|
?assertEqual(gravid, proplists:get_value(platypus, Metadata2)), |
|
|
?assertEqual(hirsute, proplists:get_value(sloth, Metadata2)), |
|
|
?assertEqual(hirsute, proplists:get_value(sloth, Metadata2)), |
|
|
@ -714,22 +714,22 @@ lager_test_() -> |
|
|
}, |
|
|
}, |
|
|
{"unsafe messages really are not truncated", |
|
|
{"unsafe messages really are not truncated", |
|
|
fun() -> |
|
|
fun() -> |
|
|
lager:info_unsafe("doom, doom has come upon you all ~p", [string:copies("doom", 1500)]), |
|
|
|
|
|
|
|
|
eRum:info_unsafe("doom, doom has come upon you all ~p", [string:copies("doom", 1500)]), |
|
|
{_, _, Msg,_Metadata} = pop(), |
|
|
{_, _, Msg,_Metadata} = pop(), |
|
|
?assert(length(lists:flatten(Msg)) == 6035) |
|
|
?assert(length(lists:flatten(Msg)) == 6035) |
|
|
end |
|
|
end |
|
|
}, |
|
|
}, |
|
|
{"can't store invalid metadata", |
|
|
{"can't store invalid metadata", |
|
|
fun() -> |
|
|
fun() -> |
|
|
?assertEqual(ok, lager:md([{platypus, gravid}, {sloth, hirsute}, {duck, erroneous}])), |
|
|
|
|
|
?assertError(badarg, lager:md({flamboyant, flamingo})), |
|
|
|
|
|
?assertError(badarg, lager:md("zookeeper zephyr")), |
|
|
|
|
|
|
|
|
?assertEqual(ok, eRum:md([{platypus, gravid}, {sloth, hirsute}, {duck, erroneous}])), |
|
|
|
|
|
?assertError(badarg, eRum:md({flamboyant, flamingo})), |
|
|
|
|
|
?assertError(badarg, eRum:md("zookeeper zephyr")), |
|
|
ok |
|
|
ok |
|
|
end |
|
|
end |
|
|
}, |
|
|
}, |
|
|
{"dates should be local by default", |
|
|
{"dates should be local by default", |
|
|
fun() -> |
|
|
fun() -> |
|
|
lager:warning("so long, and thanks for all the fish"), |
|
|
|
|
|
|
|
|
eRum:warning("so long, and thanks for all the fish"), |
|
|
?assertEqual(1, count()), |
|
|
?assertEqual(1, count()), |
|
|
{_Level, {_Date, Time}, _Message, _Metadata} = pop(), |
|
|
{_Level, {_Date, Time}, _Message, _Metadata} = pop(), |
|
|
?assertEqual(nomatch, binary:match(iolist_to_binary(Time), <<"UTC">>)), |
|
|
?assertEqual(nomatch, binary:match(iolist_to_binary(Time), <<"UTC">>)), |
|
|
@ -739,7 +739,7 @@ lager_test_() -> |
|
|
{"dates should be UTC if SASL is configured as UTC", |
|
|
{"dates should be UTC if SASL is configured as UTC", |
|
|
fun() -> |
|
|
fun() -> |
|
|
application:set_env(sasl, utc_log, true), |
|
|
application:set_env(sasl, utc_log, true), |
|
|
lager:warning("so long, and thanks for all the fish"), |
|
|
|
|
|
|
|
|
eRum:warning("so long, and thanks for all the fish"), |
|
|
application:set_env(sasl, utc_log, false), |
|
|
application:set_env(sasl, utc_log, false), |
|
|
?assertEqual(1, count()), |
|
|
?assertEqual(1, count()), |
|
|
{_Level, {_Date, Time}, _Message, _Metadata} = pop(), |
|
|
{_Level, {_Date, Time}, _Message, _Metadata} = pop(), |
|
|
@ -818,23 +818,23 @@ extra_sinks_test_() -> |
|
|
{_, T0} = lager_config:get({Sink, loglevel}), |
|
|
{_, T0} = lager_config:get({Sink, loglevel}), |
|
|
StartGlobal = lager_config:global_get(handlers), |
|
|
StartGlobal = lager_config:global_get(handlers), |
|
|
?assertEqual([], T0), |
|
|
?assertEqual([], T0), |
|
|
{ok, TestTrace1} = lager:trace_file("/tmp/test", [{sink, Sink}, {a,b}]), |
|
|
|
|
|
|
|
|
{ok, TestTrace1} = eRum:trace_file("/tmp/test", [{sink, Sink}, {a,b}]), |
|
|
MidHandlers = gen_event:which_handlers(Sink), |
|
|
MidHandlers = gen_event:which_handlers(Sink), |
|
|
{ok, TestTrace2} = lager:trace_file("/tmp/test", [{sink, Sink}, {c,d}]), |
|
|
|
|
|
|
|
|
{ok, TestTrace2} = eRum:trace_file("/tmp/test", [{sink, Sink}, {c,d}]), |
|
|
MidHandlers = gen_event:which_handlers(Sink), |
|
|
MidHandlers = gen_event:which_handlers(Sink), |
|
|
?assertEqual(length(StartHandlers)+1, length(MidHandlers)), |
|
|
?assertEqual(length(StartHandlers)+1, length(MidHandlers)), |
|
|
MidGlobal = lager_config:global_get(handlers), |
|
|
MidGlobal = lager_config:global_get(handlers), |
|
|
?assertEqual(length(StartGlobal)+1, length(MidGlobal)), |
|
|
?assertEqual(length(StartGlobal)+1, length(MidGlobal)), |
|
|
{_, T1} = lager_config:get({Sink, loglevel}), |
|
|
{_, T1} = lager_config:get({Sink, loglevel}), |
|
|
?assertEqual(2, length(T1)), |
|
|
?assertEqual(2, length(T1)), |
|
|
ok = lager:stop_trace(TestTrace1), |
|
|
|
|
|
|
|
|
ok = eRum:stop_trace(TestTrace1), |
|
|
{_, T2} = lager_config:get({Sink, loglevel}), |
|
|
{_, T2} = lager_config:get({Sink, loglevel}), |
|
|
?assertEqual(1, length(T2)), |
|
|
?assertEqual(1, length(T2)), |
|
|
?assertEqual(length(StartHandlers)+1, length( |
|
|
?assertEqual(length(StartHandlers)+1, length( |
|
|
gen_event:which_handlers(Sink))), |
|
|
gen_event:which_handlers(Sink))), |
|
|
|
|
|
|
|
|
?assertEqual(length(StartGlobal)+1, length(lager_config:global_get(handlers))), |
|
|
?assertEqual(length(StartGlobal)+1, length(lager_config:global_get(handlers))), |
|
|
ok = lager:stop_trace(TestTrace2), |
|
|
|
|
|
|
|
|
ok = eRum:stop_trace(TestTrace2), |
|
|
EndHandlers = gen_event:which_handlers(Sink), |
|
|
EndHandlers = gen_event:which_handlers(Sink), |
|
|
EndGlobal = lager_config:global_get(handlers), |
|
|
EndGlobal = lager_config:global_get(handlers), |
|
|
{_, T3} = lager_config:get({Sink, loglevel}), |
|
|
{_, T3} = lager_config:get({Sink, loglevel}), |
|
|
@ -854,12 +854,12 @@ extra_sinks_test_() -> |
|
|
?TEST_SINK_NAME:debug("this message should be ignored"), |
|
|
?TEST_SINK_NAME:debug("this message should be ignored"), |
|
|
?assertEqual(0, count(?TEST_SINK_EVENT)), |
|
|
?assertEqual(0, count(?TEST_SINK_EVENT)), |
|
|
?assertEqual(1, count_ignored(?TEST_SINK_EVENT)), |
|
|
?assertEqual(1, count_ignored(?TEST_SINK_EVENT)), |
|
|
lager:set_loglevel(?TEST_SINK_EVENT, ?MODULE, undefined, debug), |
|
|
|
|
|
|
|
|
eRum:set_loglevel(?TEST_SINK_EVENT, ?MODULE, undefined, debug), |
|
|
?assertEqual({?DEBUG bor ?INFO bor ?NOTICE bor ?WARNING bor ?ERROR bor ?CRITICAL bor ?ALERT bor ?EMERGENCY, []}, lager_config:get({?TEST_SINK_EVENT, loglevel})), |
|
|
?assertEqual({?DEBUG bor ?INFO bor ?NOTICE bor ?WARNING bor ?ERROR bor ?CRITICAL bor ?ALERT bor ?EMERGENCY, []}, lager_config:get({?TEST_SINK_EVENT, loglevel})), |
|
|
?TEST_SINK_NAME:debug("this message should be logged"), |
|
|
?TEST_SINK_NAME:debug("this message should be logged"), |
|
|
?assertEqual(1, count(?TEST_SINK_EVENT)), |
|
|
?assertEqual(1, count(?TEST_SINK_EVENT)), |
|
|
?assertEqual(1, count_ignored(?TEST_SINK_EVENT)), |
|
|
?assertEqual(1, count_ignored(?TEST_SINK_EVENT)), |
|
|
?assertEqual(debug, lager:get_loglevel(?TEST_SINK_EVENT, ?MODULE)), |
|
|
|
|
|
|
|
|
?assertEqual(debug, eRum:get_loglevel(?TEST_SINK_EVENT, ?MODULE)), |
|
|
ok |
|
|
ok |
|
|
end |
|
|
end |
|
|
} |
|
|
} |
|
|
@ -872,7 +872,7 @@ setup_sink() -> |
|
|
application:set_env(lager, handlers, []), |
|
|
application:set_env(lager, handlers, []), |
|
|
application:set_env(lager, error_logger_redirect, false), |
|
|
application:set_env(lager, error_logger_redirect, false), |
|
|
application:set_env(lager, extra_sinks, [{?TEST_SINK_EVENT, [{handlers, [{?MODULE, info}]}]}]), |
|
|
application:set_env(lager, extra_sinks, [{?TEST_SINK_EVENT, [{handlers, [{?MODULE, info}]}]}]), |
|
|
lager:start(), |
|
|
|
|
|
|
|
|
eRum:start(), |
|
|
gen_event:call(lager_event, ?MODULE, flush), |
|
|
gen_event:call(lager_event, ?MODULE, flush), |
|
|
gen_event:call(?TEST_SINK_EVENT, ?MODULE, flush). |
|
|
gen_event:call(?TEST_SINK_EVENT, ?MODULE, flush). |
|
|
|
|
|
|
|
|
@ -882,7 +882,7 @@ setup() -> |
|
|
application:set_env(lager, handlers, [{?MODULE, info}]), |
|
|
application:set_env(lager, handlers, [{?MODULE, info}]), |
|
|
application:set_env(lager, error_logger_redirect, false), |
|
|
application:set_env(lager, error_logger_redirect, false), |
|
|
application:unset_env(lager, traces), |
|
|
application:unset_env(lager, traces), |
|
|
lager:start(), |
|
|
|
|
|
|
|
|
eRum:start(), |
|
|
%% There is a race condition between the application start up, lager logging its own |
|
|
%% There is a race condition between the application start up, lager logging its own |
|
|
%% start up condition and several tests that count messages or parse the output of |
|
|
%% start up condition and several tests that count messages or parse the output of |
|
|
%% tests. When the lager start up message wins the race, it causes these tests |
|
|
%% tests. When the lager start up message wins the race, it causes these tests |
|
|
@ -954,7 +954,7 @@ error_logger_redirect_crash_setup() -> |
|
|
application:load(lager), |
|
|
application:load(lager), |
|
|
application:set_env(lager, error_logger_redirect, true), |
|
|
application:set_env(lager, error_logger_redirect, true), |
|
|
application:set_env(lager, handlers, [{?MODULE, error}]), |
|
|
application:set_env(lager, handlers, [{?MODULE, error}]), |
|
|
lager:start(), |
|
|
|
|
|
|
|
|
eRum:start(), |
|
|
crash:start(), |
|
|
crash:start(), |
|
|
lager_event. |
|
|
lager_event. |
|
|
|
|
|
|
|
|
@ -966,7 +966,7 @@ error_logger_redirect_crash_setup_sink() -> |
|
|
application:set_env(lager, extra_sinks, [ |
|
|
application:set_env(lager, extra_sinks, [ |
|
|
{error_logger_lager_event, [ |
|
|
{error_logger_lager_event, [ |
|
|
{handlers, [{?MODULE, error}]}]}]), |
|
|
{handlers, [{?MODULE, error}]}]}]), |
|
|
lager:start(), |
|
|
|
|
|
|
|
|
eRum:start(), |
|
|
crash:start(), |
|
|
crash:start(), |
|
|
error_logger_lager_event. |
|
|
error_logger_lager_event. |
|
|
|
|
|
|
|
|
@ -985,10 +985,10 @@ crash_fsm_setup() -> |
|
|
application:load(lager), |
|
|
application:load(lager), |
|
|
application:set_env(lager, error_logger_redirect, true), |
|
|
application:set_env(lager, error_logger_redirect, true), |
|
|
application:set_env(lager, handlers, [{?MODULE, error}]), |
|
|
application:set_env(lager, handlers, [{?MODULE, error}]), |
|
|
lager:start(), |
|
|
|
|
|
|
|
|
eRum:start(), |
|
|
crash_fsm:start(), |
|
|
crash_fsm:start(), |
|
|
crash_statem:start(), |
|
|
crash_statem:start(), |
|
|
lager:log(error, self(), "flush flush"), |
|
|
|
|
|
|
|
|
eRum:log(error, self(), "flush flush"), |
|
|
timer:sleep(100), |
|
|
timer:sleep(100), |
|
|
gen_event:call(lager_event, ?MODULE, flush), |
|
|
gen_event:call(lager_event, ?MODULE, flush), |
|
|
lager_event. |
|
|
lager_event. |
|
|
@ -1000,10 +1000,10 @@ crash_fsm_sink_setup() -> |
|
|
application:set_env(lager, error_logger_redirect, true), |
|
|
application:set_env(lager, error_logger_redirect, true), |
|
|
application:set_env(lager, handlers, []), |
|
|
application:set_env(lager, handlers, []), |
|
|
application:set_env(lager, extra_sinks, [{ErrorSink, [{handlers, [{?MODULE, error}]}]}]), |
|
|
application:set_env(lager, extra_sinks, [{ErrorSink, [{handlers, [{?MODULE, error}]}]}]), |
|
|
lager:start(), |
|
|
|
|
|
|
|
|
eRum:start(), |
|
|
crash_fsm:start(), |
|
|
crash_fsm:start(), |
|
|
crash_statem:start(), |
|
|
crash_statem:start(), |
|
|
lager:log(ErrorSink, error, self(), "flush flush", []), |
|
|
|
|
|
|
|
|
eRum:log(ErrorSink, error, self(), "flush flush", []), |
|
|
timer:sleep(100), |
|
|
timer:sleep(100), |
|
|
flush(ErrorSink), |
|
|
flush(ErrorSink), |
|
|
ErrorSink. |
|
|
ErrorSink. |
|
|
@ -1140,8 +1140,8 @@ error_logger_redirect_setup() -> |
|
|
application:set_env(lager, handlers, [{?MODULE, info}]), |
|
|
application:set_env(lager, handlers, [{?MODULE, info}]), |
|
|
application:set_env(lager, suppress_supervisor_start_stop, false), |
|
|
application:set_env(lager, suppress_supervisor_start_stop, false), |
|
|
application:set_env(lager, suppress_application_start_stop, false), |
|
|
application:set_env(lager, suppress_application_start_stop, false), |
|
|
lager:start(), |
|
|
|
|
|
lager:log(error, self(), "flush flush"), |
|
|
|
|
|
|
|
|
eRum:start(), |
|
|
|
|
|
eRum:log(error, self(), "flush flush"), |
|
|
timer:sleep(1000), |
|
|
timer:sleep(1000), |
|
|
gen_event:call(lager_event, ?MODULE, flush), |
|
|
gen_event:call(lager_event, ?MODULE, flush), |
|
|
lager_event. |
|
|
lager_event. |
|
|
@ -1156,8 +1156,8 @@ error_logger_redirect_setup_sink() -> |
|
|
{handlers, [{?MODULE, info}]}]}]), |
|
|
{handlers, [{?MODULE, info}]}]}]), |
|
|
application:set_env(lager, suppress_supervisor_start_stop, false), |
|
|
application:set_env(lager, suppress_supervisor_start_stop, false), |
|
|
application:set_env(lager, suppress_application_start_stop, false), |
|
|
application:set_env(lager, suppress_application_start_stop, false), |
|
|
lager:start(), |
|
|
|
|
|
lager:log(error_logger_lager_event, error, self(), "flush flush", []), |
|
|
|
|
|
|
|
|
eRum:start(), |
|
|
|
|
|
eRum:log(error_logger_lager_event, error, self(), "flush flush", []), |
|
|
timer:sleep(1000), |
|
|
timer:sleep(1000), |
|
|
gen_event:call(error_logger_lager_event, ?MODULE, flush), |
|
|
gen_event:call(error_logger_lager_event, ?MODULE, flush), |
|
|
error_logger_lager_event. |
|
|
error_logger_lager_event. |
|
|
@ -1454,7 +1454,7 @@ error_logger_redirect_test_() -> |
|
|
}, |
|
|
}, |
|
|
{"supervisor progress report", |
|
|
{"supervisor progress report", |
|
|
fun(Sink) -> |
|
|
fun(Sink) -> |
|
|
lager:set_loglevel(Sink, ?MODULE, undefined, debug), |
|
|
|
|
|
|
|
|
eRum:set_loglevel(Sink, ?MODULE, undefined, debug), |
|
|
?assertEqual({?DEBUG bor ?INFO bor ?NOTICE bor ?WARNING bor ?ERROR bor ?CRITICAL bor ?ALERT bor ?EMERGENCY, []}, lager_config:get({Sink, loglevel})), |
|
|
?assertEqual({?DEBUG bor ?INFO bor ?NOTICE bor ?WARNING bor ?ERROR bor ?CRITICAL bor ?ALERT bor ?EMERGENCY, []}, lager_config:get({Sink, loglevel})), |
|
|
sync_error_logger:info_report(progress, [{supervisor, {local, foo}}, {started, [{mfargs, {foo, bar, 1}}, {pid, baz}]}]), |
|
|
sync_error_logger:info_report(progress, [{supervisor, {local, foo}}, {started, [{mfargs, {foo, bar, 1}}, {pid, baz}]}]), |
|
|
_ = gen_event:which_handlers(error_logger), |
|
|
_ = gen_event:which_handlers(error_logger), |
|
|
@ -1466,7 +1466,7 @@ error_logger_redirect_test_() -> |
|
|
}, |
|
|
}, |
|
|
{"supervisor progress report with pid", |
|
|
{"supervisor progress report with pid", |
|
|
fun(Sink) -> |
|
|
fun(Sink) -> |
|
|
lager:set_loglevel(Sink, ?MODULE, undefined, debug), |
|
|
|
|
|
|
|
|
eRum:set_loglevel(Sink, ?MODULE, undefined, debug), |
|
|
?assertEqual({?DEBUG bor ?INFO bor ?NOTICE bor ?WARNING bor ?ERROR bor ?CRITICAL bor ?ALERT bor ?EMERGENCY, []}, lager_config:get({Sink, loglevel})), |
|
|
?assertEqual({?DEBUG bor ?INFO bor ?NOTICE bor ?WARNING bor ?ERROR bor ?CRITICAL bor ?ALERT bor ?EMERGENCY, []}, lager_config:get({Sink, loglevel})), |
|
|
sync_error_logger:info_report(progress, [{supervisor, somepid}, {started, [{mfargs, {foo, bar, 1}}, {pid, baz}]}]), |
|
|
sync_error_logger:info_report(progress, [{supervisor, somepid}, {started, [{mfargs, {foo, bar, 1}}, {pid, baz}]}]), |
|
|
_ = gen_event:which_handlers(error_logger), |
|
|
_ = gen_event:which_handlers(error_logger), |
|
|
@ -1693,19 +1693,19 @@ error_logger_redirect_test_() -> |
|
|
}, |
|
|
}, |
|
|
{"messages should not be generated if they don't satisfy the threshold", |
|
|
{"messages should not be generated if they don't satisfy the threshold", |
|
|
fun(Sink) -> |
|
|
fun(Sink) -> |
|
|
lager:set_loglevel(Sink, ?MODULE, undefined, error), |
|
|
|
|
|
|
|
|
eRum:set_loglevel(Sink, ?MODULE, undefined, error), |
|
|
?assertEqual({?ERROR bor ?CRITICAL bor ?ALERT bor ?EMERGENCY, []}, lager_config:get({Sink, loglevel})), |
|
|
?assertEqual({?ERROR bor ?CRITICAL bor ?ALERT bor ?EMERGENCY, []}, lager_config:get({Sink, loglevel})), |
|
|
sync_error_logger:info_report([hello, world]), |
|
|
sync_error_logger:info_report([hello, world]), |
|
|
_ = gen_event:which_handlers(error_logger), |
|
|
_ = gen_event:which_handlers(error_logger), |
|
|
?assertEqual(0, count(Sink)), |
|
|
?assertEqual(0, count(Sink)), |
|
|
?assertEqual(0, count_ignored(Sink)), |
|
|
?assertEqual(0, count_ignored(Sink)), |
|
|
lager:set_loglevel(Sink, ?MODULE, undefined, info), |
|
|
|
|
|
|
|
|
eRum:set_loglevel(Sink, ?MODULE, undefined, info), |
|
|
?assertEqual({?INFO bor ?NOTICE bor ?WARNING bor ?ERROR bor ?CRITICAL bor ?ALERT bor ?EMERGENCY, []}, lager_config:get({Sink, loglevel})), |
|
|
?assertEqual({?INFO bor ?NOTICE bor ?WARNING bor ?ERROR bor ?CRITICAL bor ?ALERT bor ?EMERGENCY, []}, lager_config:get({Sink, loglevel})), |
|
|
sync_error_logger:info_report([hello, world]), |
|
|
sync_error_logger:info_report([hello, world]), |
|
|
_ = gen_event:which_handlers(error_logger), |
|
|
_ = gen_event:which_handlers(error_logger), |
|
|
?assertEqual(1, count(Sink)), |
|
|
?assertEqual(1, count(Sink)), |
|
|
?assertEqual(0, count_ignored(Sink)), |
|
|
?assertEqual(0, count_ignored(Sink)), |
|
|
lager:set_loglevel(Sink, ?MODULE, undefined, error), |
|
|
|
|
|
|
|
|
eRum:set_loglevel(Sink, ?MODULE, undefined, error), |
|
|
?assertEqual({?ERROR bor ?CRITICAL bor ?ALERT bor ?EMERGENCY, []}, lager_config:get({Sink, loglevel})), |
|
|
?assertEqual({?ERROR bor ?CRITICAL bor ?ALERT bor ?EMERGENCY, []}, lager_config:get({Sink, loglevel})), |
|
|
lager_config:set({Sink, loglevel}, {element(2, rumUtil:config_to_mask(debug)), []}), |
|
|
lager_config:set({Sink, loglevel}, {element(2, rumUtil:config_to_mask(debug)), []}), |
|
|
sync_error_logger:info_report([hello, world]), |
|
|
sync_error_logger:info_report([hello, world]), |
|
|
@ -1734,13 +1734,13 @@ error_logger_redirect_test_() -> |
|
|
]}. |
|
|
]}. |
|
|
|
|
|
|
|
|
safe_format_test() -> |
|
|
safe_format_test() -> |
|
|
?assertEqual("foo bar", lists:flatten(lager:safe_format("~p ~p", [foo, bar], 1024))), |
|
|
|
|
|
?assertEqual("FORMAT ERROR: \"~p ~p ~p\" [foo,bar]", lists:flatten(lager:safe_format("~p ~p ~p", [foo, bar], 1024))), |
|
|
|
|
|
|
|
|
?assertEqual("foo bar", lists:flatten(eRum:safe_format("~p ~p", [foo, bar], 1024))), |
|
|
|
|
|
?assertEqual("FORMAT ERROR: \"~p ~p ~p\" [foo,bar]", lists:flatten(eRum:safe_format("~p ~p ~p", [foo, bar], 1024))), |
|
|
ok. |
|
|
ok. |
|
|
|
|
|
|
|
|
unsafe_format_test() -> |
|
|
unsafe_format_test() -> |
|
|
?assertEqual("foo bar", lists:flatten(lager:unsafe_format("~p ~p", [foo, bar]))), |
|
|
|
|
|
?assertEqual("FORMAT ERROR: \"~p ~p ~p\" [foo,bar]", lists:flatten(lager:unsafe_format("~p ~p ~p", [foo, bar]))), |
|
|
|
|
|
|
|
|
?assertEqual("foo bar", lists:flatten(eRum:unsafe_format("~p ~p", [foo, bar]))), |
|
|
|
|
|
?assertEqual("FORMAT ERROR: \"~p ~p ~p\" [foo,bar]", lists:flatten(eRum:unsafe_format("~p ~p ~p", [foo, bar]))), |
|
|
ok. |
|
|
ok. |
|
|
|
|
|
|
|
|
async_threshold_test_() -> |
|
|
async_threshold_test_() -> |
|
|
@ -1770,7 +1770,7 @@ async_threshold_test_() -> |
|
|
ok = application:set_env(lager, async_threshold, 2), |
|
|
ok = application:set_env(lager, async_threshold, 2), |
|
|
ok = application:set_env(lager, async_threshold_window, 1), |
|
|
ok = application:set_env(lager, async_threshold_window, 1), |
|
|
ok = application:set_env(lager, handlers, [{?MODULE, info}]), |
|
|
ok = application:set_env(lager, handlers, [{?MODULE, info}]), |
|
|
ok = lager:start(), |
|
|
|
|
|
|
|
|
ok = eRum:start(), |
|
|
true |
|
|
true |
|
|
end, |
|
|
end, |
|
|
{foreach, Setup, Cleanup, [ |
|
|
{foreach, Setup, Cleanup, [ |
|
|
@ -1811,7 +1811,7 @@ async_threshold_test_() -> |
|
|
_ = gen_event:which_handlers(lager_event), |
|
|
_ = gen_event:which_handlers(lager_event), |
|
|
timer:sleep(Sleep), |
|
|
timer:sleep(Sleep), |
|
|
|
|
|
|
|
|
lager:info("hello world"), |
|
|
|
|
|
|
|
|
eRum:info("hello world"), |
|
|
|
|
|
|
|
|
_ = gen_event:which_handlers(lager_event), |
|
|
_ = gen_event:which_handlers(lager_event), |
|
|
timer:sleep(Sleep), |
|
|
timer:sleep(Sleep), |
|
|
@ -1839,7 +1839,7 @@ message_stuffer(N, Level, Message) -> |
|
|
message_stuffer_(0, _, _, _) -> |
|
|
message_stuffer_(0, _, _, _) -> |
|
|
ok; |
|
|
ok; |
|
|
message_stuffer_(N, Level, Meta, Message) -> |
|
|
message_stuffer_(N, Level, Meta, Message) -> |
|
|
lager:log(Level, Meta, Message), |
|
|
|
|
|
|
|
|
eRum:log(Level, Meta, Message), |
|
|
message_stuffer_((N - 1), Level, Meta, Message). |
|
|
message_stuffer_((N - 1), Level, Meta, Message). |
|
|
|
|
|
|
|
|
collect_workers([]) -> |
|
|
collect_workers([]) -> |
|
|
@ -1865,7 +1865,7 @@ high_watermark_test_() -> |
|
|
application:set_env(lager, error_logger_redirect, true), |
|
|
application:set_env(lager, error_logger_redirect, true), |
|
|
application:set_env(lager, handlers, [{lager_test_backend, info}]), |
|
|
application:set_env(lager, handlers, [{lager_test_backend, info}]), |
|
|
application:set_env(lager, async_threshold, undefined), |
|
|
application:set_env(lager, async_threshold, undefined), |
|
|
lager:start() |
|
|
|
|
|
|
|
|
eRum:start() |
|
|
end, |
|
|
end, |
|
|
fun(_) -> |
|
|
fun(_) -> |
|
|
application:stop(lager), |
|
|
application:stop(lager), |
|
|
|
