diff --git a/include/rum.hrl b/include/rum.hrl index 0a5f46a..2493678 100644 --- a/include/rum.hrl +++ b/include/rum.hrl @@ -94,13 +94,13 @@ -endif. -define(rumLog(Severity, Format, Args, Safety), - ?rumLog(?RumDefSink, Severity, ?RumMetadata(lager:md()), Format, Args, ?RumDefTruncation, Safety)). + ?rumLog(?RumDefSink, Severity, ?RumMetadata(eRum:md()), Format, Args, ?RumDefTruncation, Safety)). -define(rumLog(Severity, Metadata, Format, Args, Safety), - ?rumLog(?RumDefSink, Severity, ?RumMetadata(Metadata ++ lager:md()), Format, Args, ?RumDefTruncation, Safety)). + ?rumLog(?RumDefSink, Severity, ?RumMetadata(Metadata ++ eRum:md()), Format, Args, ?RumDefTruncation, Safety)). -define(rumLog(Sink, Severity, Metadata, Format, Args, Size, Safety), - _ = lager:dispatch_log(Sink, Severity, Metadata, Format, Args, Size, Safety)). + _ = eRum:dispatch_log(Sink, Severity, Metadata, Format, Args, Size, Safety)). -define(rumDebug(Format, Args), ?rumLog(debug, Format, Args, safe)). -define(rumDebug(Metadata, Format, Args), ?rumLog(debug, Metadata, Format, Args, safe)). diff --git a/src/lager.erl b/src/eRum.erl similarity index 99% rename from src/lager.erl rename to src/eRum.erl index 335d0a9..438ccad 100644 --- a/src/lager.erl +++ b/src/eRum.erl @@ -16,7 +16,7 @@ %% @doc The lager logging framework. --module(lager). +-module(eRum). -include("rum.hrl"). @@ -697,7 +697,7 @@ rotate_handler(Handler, Sink) -> %% @private trace_func(#trace_func_state_v1{pid=Pid, level=Level, format_string=Fmt}=FuncState, Event, ProcState) -> - _ = lager:log(Level, Pid, Fmt, [Event, ProcState]), + _ = eRum:log(Level, Pid, Fmt, [Event, ProcState]), check_timeout(decrement_count(FuncState)). %% @private diff --git a/src/eRum_app.erl b/src/eRum_app.erl index b5e94b9..12300ad 100644 --- a/src/eRum_app.erl +++ b/src/eRum_app.erl @@ -103,7 +103,7 @@ clean_up_config_checks() -> interpret_hwm(undefined) -> undefined; interpret_hwm(HWM) when not is_integer(HWM) orelse HWM < 0 -> - _ = lager:log(warning, self(), "Invalid error_logger high water mark: ~p, disabling", [HWM]), + _ = eRum:log(warning, self(), "Invalid error_logger high water mark: ~p, disabling", [HWM]), undefined; interpret_hwm(HWM) -> HWM. @@ -192,7 +192,7 @@ configure_sink(Sink, SinkDef) -> start_handlers(Sink, proplists:get_value(handlers, SinkDef, [])), - lager:update_loglevel_config(Sink). + eRum:update_loglevel_config(Sink). configure_extra_sinks(Sinks) -> @@ -223,7 +223,7 @@ boot() -> start_handlers(?RumDefSink, application:get_env(lager, handlers, ?DEFAULT_HANDLER_CONF)), - lager:update_loglevel_config(?RumDefSink), + eRum:update_loglevel_config(?RumDefSink), SavedHandlers = start_error_logger_handler( application:get_env(lager, error_logger_redirect, true), @@ -282,9 +282,9 @@ add_configured_traces() -> ok. start_configured_trace({Handler, Filter}) -> - {ok, _} = lager:trace(Handler, Filter); + {ok, _} = eRum:trace(Handler, Filter); start_configured_trace({Handler, Filter, Level}) when is_atom(Level) -> - {ok, _} = lager:trace(Handler, Filter, Level). + {ok, _} = eRum:trace(Handler, Filter, Level). maybe_make_handler_id(Mod, Config) -> %% Allow the backend to generate a gen_event handler id, if it wants to. diff --git a/src/lager_default_formatter.erl b/src/formater/lager_default_formatter.erl similarity index 100% rename from src/lager_default_formatter.erl rename to src/formater/lager_default_formatter.erl diff --git a/src/lager_format.erl b/src/formater/lager_format.erl similarity index 100% rename from src/lager_format.erl rename to src/formater/lager_format.erl diff --git a/src/error_logger_lager_h.erl b/src/misc/error_logger_lager_h.erl similarity index 99% rename from src/error_logger_lager_h.erl rename to src/misc/error_logger_lager_h.erl index 72dcd19..5773e78 100644 --- a/src/error_logger_lager_h.erl +++ b/src/misc/error_logger_lager_h.erl @@ -44,7 +44,7 @@ -define(LOGMSG(Sink, Level, Pid, Msg), case ?RunShouldLog(Sink, Level) of true -> - _ =lager:log(Sink, Level, Pid, Msg, []), + _ = eRum:log(Sink, Level, Pid, Msg, []), logged; _ -> no_log end). @@ -52,7 +52,7 @@ -define(LOGFMT(Sink, Level, Pid, Fmt, Args), case ?RunShouldLog(Sink, Level) of true -> - _ = lager:log(Sink, Level, Pid, Fmt, Args), + _ = eRum:log(Sink, Level, Pid, Fmt, Args), logged; _ -> no_log end). @@ -640,7 +640,7 @@ no_silent_hwm_drops_test_() -> application:set_env(lager, suppress_supervisor_start_stop, true), application:set_env(lager, suppress_application_start_stop, true), application:unset_env(lager, crash_log), - lager:start(), + eRum:start(), try {_, _, MS} = os:timestamp(), timer:sleep((1000000 - MS) div 1000 + 1), @@ -670,7 +670,7 @@ shaper_does_not_forward_sup_progress_messages_to_info_level_backend_test_() -> application:set_env(lager, suppress_supervisor_start_stop, false), application:set_env(lager, suppress_application_start_stop, false), application:unset_env(lager, crash_log), - lager:start(), + eRum:start(), try PidPlaceholder = self(), SupervisorMsg = @@ -719,7 +719,7 @@ supressed_messages_are_not_counted_for_hwm_test_() -> application:set_env(lager, suppress_supervisor_start_stop, true), application:set_env(lager, suppress_application_start_stop, true), application:unset_env(lager, crash_log), - lager:start(), + eRum:start(), try PidPlaceholder = self(), SupervisorMsg = diff --git a/src/lager_backend_throttle.erl b/src/misc/lager_backend_throttle.erl similarity index 100% rename from src/lager_backend_throttle.erl rename to src/misc/lager_backend_throttle.erl diff --git a/src/lager_config.erl b/src/misc/lager_config.erl similarity index 100% rename from src/lager_config.erl rename to src/misc/lager_config.erl diff --git a/src/lager_console_backend.erl b/src/misc/lager_console_backend.erl similarity index 92% rename from src/lager_console_backend.erl rename to src/misc/lager_console_backend.erl index 37ada6a..f720095 100644 --- a/src/lager_console_backend.erl +++ b/src/misc/lager_console_backend.erl @@ -193,7 +193,7 @@ handle_info(_Info, State) -> %% @private terminate(remove_handler, _State=#state{id=ID}) -> %% have to do this asynchronously because we're in the event handlr - spawn(fun() -> lager:clear_trace_by_destination(ID) end), + spawn(fun() -> eRum:clear_trace_by_destination(ID) end), ok; terminate(_Reason, _State) -> ok. @@ -269,7 +269,7 @@ console_log_test_() -> application:load(lager), application:set_env(lager, handlers, []), application:set_env(lager, error_logger_redirect, false), - lager:start(), + eRum:start(), whereis(user) end, fun(User) -> @@ -288,7 +288,7 @@ console_log_test_() -> erlang:group_leader(Pid, whereis(lager_event)), gen_event:add_handler(lager_event, lager_console_backend, [{level, info}]), lager_config:set({lager_event, loglevel}, {element(2, rumUtil:config_to_mask(info)), []}), - lager:log(info, self(), "Test message"), + eRum:log(info, self(), "Test message"), receive {io_request, From, ReplyAs, {put_chars, unicode, Msg}} -> From ! {io_reply, ReplyAs, ok}, @@ -308,7 +308,7 @@ console_log_test_() -> erlang:group_leader(Pid, whereis(lager_event)), gen_event:add_handler(lager_event, lager_console_backend, [info, true]), lager_config:set({lager_event, loglevel}, {element(2, rumUtil:config_to_mask(info)), []}), - lager:info("Test message"), + eRum:info("Test message"), PidStr = pid_to_list(self()), receive {io_request, _, _, {put_chars, unicode, Msg}} -> @@ -330,7 +330,7 @@ console_log_test_() -> [{level, info}, {formatter, lager_default_formatter}, {formatter_config, [date,"#",time,"#",severity,"#",node,"#",pid,"#", module,"#",function,"#",file,"#",line,"#",message,"\r\n"]}]), lager_config:set({lager_event, loglevel}, {?INFO, []}), - lager:info("Test message"), + eRum:info("Test message"), PidStr = pid_to_list(self()), NodeStr = atom_to_list(node()), ModuleStr = atom_to_list(?MODULE), @@ -353,7 +353,7 @@ console_log_test_() -> gen_event:add_handler(lager_event, lager_console_backend, [{level, info}]), erlang:group_leader(Pid, whereis(lager_event)), lager_config:set({lager_event, loglevel}, {element(2, rumUtil:config_to_mask(info)), []}), - lager:debug("Test message"), + eRum:debug("Test message"), receive {io_request, From, ReplyAs, {put_chars, unicode, _Msg}} -> From ! {io_reply, ReplyAs, ok}, @@ -362,8 +362,8 @@ console_log_test_() -> 500 -> ?assert(true) end, - {ok, _} = lager:trace_console([{module, ?MODULE}]), - lager:debug("Test message"), + {ok, _} = eRum:trace_console([{module, ?MODULE}]), + eRum:debug("Test message"), receive {io_request, From1, ReplyAs1, {put_chars, unicode, Msg1}} -> From1 ! {io_reply, ReplyAs1, ok}, @@ -383,7 +383,7 @@ console_log_test_() -> gen_event:add_handler(lager_event, lager_console_backend, [{level, info}]), lager_config:set({lager_event, loglevel}, {element(2, rumUtil:config_to_mask(info)), []}), erlang:group_leader(Pid, whereis(lager_event)), - lager:debug("Test message"), + eRum:debug("Test message"), receive {io_request, From, ReplyAs, {put_chars, unicode, _Msg}} -> From ! {io_reply, ReplyAs, ok}, @@ -392,8 +392,8 @@ console_log_test_() -> 500 -> ?assert(true) end, - {ok, _} = lager:trace_console([{module, ?MODULE}]), - lager:error("Test message"), + {ok, _} = eRum:trace_console([{module, ?MODULE}]), + eRum:error("Test message"), receive {io_request, From1, ReplyAs1, {put_chars, unicode, Msg1}} -> From1 ! {io_reply, ReplyAs1, ok}, @@ -421,9 +421,9 @@ console_log_test_() -> register(user, Pid), gen_event:add_handler(lager_event, lager_console_backend, [{level, info}]), lager_config:set({lager_event, loglevel}, {element(2, rumUtil:config_to_mask(info)), []}), - lager:set_loglevel(lager_console_backend, '!=info'), + eRum:set_loglevel(lager_console_backend, '!=info'), erlang:group_leader(Pid, whereis(lager_event)), - lager:debug("Test message"), + eRum:debug("Test message"), receive {io_request, From1, ReplyAs1, {put_chars, unicode, Msg1}} -> From1 ! {io_reply, ReplyAs1, ok}, @@ -434,7 +434,7 @@ console_log_test_() -> ?assert(false) end, %% info is blacklisted - lager:info("Test message"), + eRum:info("Test message"), receive {io_request, From2, ReplyAs2, {put_chars, unicode, _Msg2}} -> From2 ! {io_reply, ReplyAs2, ok}, @@ -452,9 +452,9 @@ console_log_test_() -> register(user, Pid), gen_event:add_handler(lager_event, lager_console_backend, [{level, info}]), lager_config:set({lager_event, loglevel}, {element(2, rumUtil:config_to_mask(info)), []}), - lager:set_loglevel(lager_console_backend, '=debug'), + eRum:set_loglevel(lager_console_backend, '=debug'), erlang:group_leader(Pid, whereis(lager_event)), - lager:debug("Test message"), + eRum:debug("Test message"), receive {io_request, From1, ReplyAs1, {put_chars, unicode, Msg1}} -> From1 ! {io_reply, ReplyAs1, ok}, @@ -465,7 +465,7 @@ console_log_test_() -> ?assert(false) end, %% info is blacklisted - lager:error("Test message"), + eRum:error("Test message"), receive {io_request, From2, ReplyAs2, {put_chars, unicode, _Msg2}} -> From2 ! {io_reply, ReplyAs2, ok}, @@ -481,7 +481,7 @@ console_log_test_() -> Pid = spawn(F(self())), gen_event:add_handler(lager_event, lager_console_backend, [{level, info}, {group_leader, Pid}]), lager_config:set({lager_event, loglevel}, {element(2, rumUtil:config_to_mask(info)), []}), - lager:info("Test message"), + eRum:info("Test message"), ?assertNotEqual({group_leader, Pid}, erlang:process_info(whereis(lager_event), group_leader)), receive {io_request, From1, ReplyAs1, {put_chars, unicode, Msg1}} -> @@ -498,7 +498,7 @@ console_log_test_() -> timer:sleep(100), %% additionally, check the lager backend has been removed (because the group leader process died) ?assertNot(lists:member(lager_console_backend, gen_event:which_handlers(lager_event))), - lager:error("Test message"), + eRum:error("Test message"), receive {io_request, From2, ReplyAs2, {put_chars, unicode, _Msg2}} -> From2 ! {io_reply, ReplyAs2, ok}, @@ -518,7 +518,7 @@ console_log_test_() -> [{level, none}, {group_leader, Pid}, {id, ID}]), lager_config:global_set(handlers, [HandlerInfo|Handlers]), - lager:info("Test message"), + eRum:info("Test message"), ?assertNotEqual({group_leader, Pid}, erlang:process_info(whereis(lager_event), group_leader)), receive {io_request, From, ReplyAs, {put_chars, unicode, _Msg}} -> @@ -528,8 +528,8 @@ console_log_test_() -> 500 -> ?assert(true) end, - lager:trace(ID, [{module, ?MODULE}], debug), - lager:info("Test message"), + eRum:trace(ID, [{module, ?MODULE}], debug), + eRum:info("Test message"), receive {io_request, From1, ReplyAs1, {put_chars, unicode, Msg1}} -> From1 ! {io_reply, ReplyAs1, ok}, @@ -548,7 +548,7 @@ console_log_test_() -> ?assertNot(lists:member(lager_console_backend, gen_event:which_handlers(lager_event))), %% finally, check the trace has been removed ?assertEqual({0, []}, lager_config:get({lager_event, loglevel})), - lager:error("Test message"), + eRum:error("Test message"), receive {io_request, From3, ReplyAs3, {put_chars, unicode, _Msg3}} -> From3 ! {io_reply, ReplyAs3, ok}, @@ -569,7 +569,7 @@ set_loglevel_test_() -> application:load(lager), application:set_env(lager, handlers, [{lager_console_backend, [{level, info}]}]), application:set_env(lager, error_logger_redirect, false), - lager:start() + eRum:start() end, fun(_) -> application:stop(lager), @@ -579,22 +579,22 @@ set_loglevel_test_() -> [ {"Get/set loglevel test", fun() -> - ?assertEqual(info, lager:get_loglevel(lager_console_backend)), - lager:set_loglevel(lager_console_backend, debug), - ?assertEqual(debug, lager:get_loglevel(lager_console_backend)), - lager:set_loglevel(lager_console_backend, '!=debug'), - ?assertEqual(info, lager:get_loglevel(lager_console_backend)), - lager:set_loglevel(lager_console_backend, '!=info'), - ?assertEqual(debug, lager:get_loglevel(lager_console_backend)), + ?assertEqual(info, eRum:get_loglevel(lager_console_backend)), + eRum:set_loglevel(lager_console_backend, debug), + ?assertEqual(debug, eRum:get_loglevel(lager_console_backend)), + eRum:set_loglevel(lager_console_backend, '!=debug'), + ?assertEqual(info, eRum:get_loglevel(lager_console_backend)), + eRum:set_loglevel(lager_console_backend, '!=info'), + ?assertEqual(debug, eRum:get_loglevel(lager_console_backend)), ok end }, {"Get/set invalid loglevel test", fun() -> - ?assertEqual(info, lager:get_loglevel(lager_console_backend)), + ?assertEqual(info, eRum:get_loglevel(lager_console_backend)), ?assertEqual({error, bad_log_level}, - lager:set_loglevel(lager_console_backend, fatfinger)), - ?assertEqual(info, lager:get_loglevel(lager_console_backend)) + eRum:set_loglevel(lager_console_backend, fatfinger)), + ?assertEqual(info, eRum:get_loglevel(lager_console_backend)) end } diff --git a/src/lager_crash_log.erl b/src/misc/lager_crash_log.erl similarity index 99% rename from src/lager_crash_log.erl rename to src/misc/lager_crash_log.erl index 0a4264a..7116381 100644 --- a/src/lager_crash_log.erl +++ b/src/misc/lager_crash_log.erl @@ -134,7 +134,7 @@ schedule_rotation(Date) -> %% to limit the formatted string's size. limited_fmt(Fmt, Args, FmtMaxBytes) -> - lager:safe_format(Fmt, Args, FmtMaxBytes). + eRum:safe_format(Fmt, Args, FmtMaxBytes). limited_str(Term, FmtMaxBytes) -> {Str, _} = lager_trunc_io:print(Term, FmtMaxBytes), @@ -251,7 +251,7 @@ filesystem_test_() -> ok = application:set_env(lager, handlers, [{lager_test_backend, info}]), ok = application:set_env(lager, error_logger_redirect, true), ok = application:unset_env(lager, crash_log), - ok = lager:start(), + ok = eRum:start(), ok = timer:sleep(1000), ok = lager_test_backend:flush(), CrashLog diff --git a/src/lager_file_backend.erl b/src/misc/lager_file_backend.erl similarity index 93% rename from src/lager_file_backend.erl rename to src/misc/lager_file_backend.erl index c3a36c5..0bbda8b 100644 --- a/src/lager_file_backend.erl +++ b/src/misc/lager_file_backend.erl @@ -81,14 +81,14 @@ os_type :: atom() }). --type option() :: {file, string()} | {level, lager:log_level()} | +-type option() :: {file, string()} | {level, eRum:log_level()} | {size, non_neg_integer()} | {date, string()} | {count, non_neg_integer()} | {rotator, atom()} | {high_water_mark, non_neg_integer()} | {flush_queue, boolean()} | {flush_threshold, non_neg_integer()} | {sync_interval, non_neg_integer()} | - {sync_size, non_neg_integer()} | {sync_on, lager:log_level()} | + {sync_size, non_neg_integer()} | {sync_on, eRum:log_level()} | {check_interval, non_neg_integer()} | {formatter, atom()} | {formatter_config, term()}. @@ -613,7 +613,7 @@ filesystem_test_() -> ok = application:set_env(lager, error_logger_redirect, false), ok = application:set_env(lager, async_threshold, undefined), {ok, _TestDir} = rumUtil:create_test_dir(), - ok = lager:start(), + ok = eRum:start(), %% race condition where lager logs its own start up %% makes several tests fail. See test/lager_test_backend %% around line 800 for more information. @@ -633,7 +633,7 @@ filesystem_test_() -> gen_event:add_handler(lager_event, lager_file_backend, [{TestLog, info}, {lager_default_formatter}]), - lager:log(error, self(), "Test message"), + eRum:log(error, self(), "Test message"), {ok, Bin} = file:read_file(TestLog), Pid = pid_to_list(self()), ?assertMatch([_, _, "[error]", Pid, "Test message\n"], @@ -646,7 +646,7 @@ filesystem_test_() -> gen_event:add_handler(lager_event, lager_file_backend, [{TestLog, info}, {lager_default_formatter}]), - lager:log(error, self(),"~ts", [[20013,25991,27979,35797]]), + eRum:log(error, self(),"~ts", [[20013,25991,27979,35797]]), {ok, Bin} = file:read_file(TestLog), Pid = pid_to_list(self()), ?assertMatch([_, _, "[error]", Pid, @@ -661,7 +661,7 @@ filesystem_test_() -> %% XXX if this test fails, check that this file is encoded latin-1, not utf-8! gen_event:add_handler(lager_event, lager_file_backend, [{TestLog, info}, {lager_default_formatter}]), - lager:log(error, self(),"~ts", [[76, 198, 221, 206, 78, $-, 239]]), + eRum:log(error, self(),"~ts", [[76, 198, 221, 206, 78, $-, 239]]), {ok, Bin} = file:read_file(TestLog), Pid = pid_to_list(self()), Res = re:split(Bin, " ", [{return, list}, {parts, 5}]), @@ -706,14 +706,14 @@ filesystem_test_() -> gen_event:add_handler(lager_event, lager_file_backend, [{file, TestLog}, {level, info}, {check_interval, 0}]), ?assertEqual(0, lager_test_backend:count()), - lager:log(error, self(), "Test message"), + eRum:log(error, self(), "Test message"), ?assertEqual(1, lager_test_backend:count()), ?assertEqual(ok, file:delete(TestLog)), ?assertEqual(ok, rumUtil:safe_write_file(TestLog, "")), {ok, FInfo0} = file:read_file_info(TestLog, [raw]), FInfo1 = FInfo0#file_info{mode = 0}, ?assertEqual(ok, file:write_file_info(TestLog, FInfo1)), - lager:log(error, self(), "Test message"), + eRum:log(error, self(), "Test message"), lager_test_backend:pop(), lager_test_backend:pop(), {_Level, _Time, Message, _Metadata} = lager_test_backend:pop(), @@ -739,7 +739,7 @@ filesystem_test_() -> "Failed to open log file " ++ TestLog ++ " with error permission denied", lists:flatten(Message)), ?assertEqual(ok, file:write_file_info(TestLog, FInfo#file_info{mode = OldPerms})), - lager:log(error, self(), "Test message"), + eRum:log(error, self(), "Test message"), {ok, Bin} = file:read_file(TestLog), Pid = pid_to_list(self()), ?assertMatch([_, _, "[error]", Pid, "Test message\n"], @@ -760,18 +760,18 @@ filesystem_test_() -> gen_event:add_handler(lager_event, lager_file_backend, [{file, TestLog}, {level, info}, {check_interval, 0}]), ?assertEqual(0, lager_test_backend:count()), - lager:log(error, self(), "Test message1"), + eRum:log(error, self(), "Test message1"), ?assertEqual(1, lager_test_backend:count()), ?assertEqual(ok, file:delete(TestLog)), ?assertEqual(ok, rumUtil:safe_write_file(TestLog, "")), - lager:log(error, self(), "Test message2"), + eRum:log(error, self(), "Test message2"), ?assertEqual(2, lager_test_backend:count()), {ok, Bin} = file:read_file(TestLog), Pid = pid_to_list(self()), ?assertMatch([_, _, "[error]", Pid, "Test message2\n"], re:split(Bin, " ", [{return, list}, {parts, 5}])), ?assertEqual(ok, file:rename(TestLog, TestLog0)), - lager:log(error, self(), "Test message3"), + eRum:log(error, self(), "Test message3"), ?assertEqual(3, lager_test_backend:count()), {ok, Bin2} = file:read_file(TestLog), ?assertMatch([_, _, "[error]", Pid, "Test message3\n"], @@ -786,8 +786,8 @@ filesystem_test_() -> gen_event:add_handler(lager_event, lager_file_backend, [{file, TestLog}, {level, info}, {check_interval, 0}, {size, 10}]), - lager:log(error, self(), "Test message1"), - lager:log(error, self(), "Test message1"), + eRum:log(error, self(), "Test message1"), + eRum:log(error, self(), "Test message1"), ?assert(filelib:is_regular(TestLog0)) end}, {"internal time rotation should work", @@ -798,10 +798,10 @@ filesystem_test_() -> gen_event:add_handler(lager_event, lager_file_backend, [{file, TestLog}, {level, info}, {check_interval, 1000}]), - lager:log(error, self(), "Test message1"), - lager:log(error, self(), "Test message1"), + eRum:log(error, self(), "Test message1"), + eRum:log(error, self(), "Test message1"), whereis(lager_event) ! {rotate, TestLog}, - lager:log(error, self(), "Test message1"), + eRum:log(error, self(), "Test message1"), ?assert(filelib:is_regular(TestLog0)) end}, {"rotation call should work", @@ -812,10 +812,10 @@ filesystem_test_() -> gen_event:add_handler(lager_event, {lager_file_backend, TestLog}, [{file, TestLog}, {level, info}, {check_interval, 1000}]), - lager:log(error, self(), "Test message1"), - lager:log(error, self(), "Test message1"), + eRum:log(error, self(), "Test message1"), + eRum:log(error, self(), "Test message1"), gen_event:call(lager_event, {lager_file_backend, TestLog}, rotate, infinity), - lager:log(error, self(), "Test message1"), + eRum:log(error, self(), "Test message1"), ?assert(filelib:is_regular(TestLog0)) end}, {"sync_on option should work", @@ -825,10 +825,10 @@ filesystem_test_() -> gen_event:add_handler(lager_event, lager_file_backend, [{file, TestLog}, {level, info}, {sync_on, "=info"}, {check_interval, 5000}, {sync_interval, 5000}]), - lager:log(error, self(), "Test message1"), - lager:log(error, self(), "Test message1"), + eRum:log(error, self(), "Test message1"), + eRum:log(error, self(), "Test message1"), ?assertEqual({ok, <<>>}, file:read_file(TestLog)), - lager:log(info, self(), "Test message1"), + eRum:log(info, self(), "Test message1"), {ok, Bin} = file:read_file(TestLog), ?assert(<<>> /= Bin) end}, @@ -839,10 +839,10 @@ filesystem_test_() -> gen_event:add_handler(lager_event, lager_file_backend, [{file, TestLog}, {level, info}, {sync_on, "none"}, {check_interval, 5000}, {sync_interval, 1000}]), - lager:log(error, self(), "Test message1"), - lager:log(error, self(), "Test message1"), + eRum:log(error, self(), "Test message1"), + eRum:log(error, self(), "Test message1"), ?assertEqual({ok, <<>>}, file:read_file(TestLog)), - lager:log(info, self(), "Test message1"), + eRum:log(info, self(), "Test message1"), ?assertEqual({ok, <<>>}, file:read_file(TestLog)), timer:sleep(2000), {ok, Bin} = file:read_file(TestLog), @@ -855,19 +855,19 @@ filesystem_test_() -> gen_event:add_handler(lager_event, lager_file_backend, [{file, TestLog}, {level, info}, {sync_on, "none"}, {check_interval, 5001}, {sync_size, 640}, {sync_interval, 5001}]), - lager:log(error, self(), "Test messageis64bytes"), - lager:log(error, self(), "Test messageis64bytes"), - lager:log(error, self(), "Test messageis64bytes"), - lager:log(error, self(), "Test messageis64bytes"), - lager:log(error, self(), "Test messageis64bytes"), + eRum:log(error, self(), "Test messageis64bytes"), + eRum:log(error, self(), "Test messageis64bytes"), + eRum:log(error, self(), "Test messageis64bytes"), + eRum:log(error, self(), "Test messageis64bytes"), + eRum:log(error, self(), "Test messageis64bytes"), ?assertEqual({ok, <<>>}, file:read_file(TestLog)), - lager:log(error, self(), "Test messageis64bytes"), - lager:log(error, self(), "Test messageis64bytes"), - lager:log(error, self(), "Test messageis64bytes"), - lager:log(error, self(), "Test messageis64bytes"), + eRum:log(error, self(), "Test messageis64bytes"), + eRum:log(error, self(), "Test messageis64bytes"), + eRum:log(error, self(), "Test messageis64bytes"), + eRum:log(error, self(), "Test messageis64bytes"), ?assertEqual({ok, <<>>}, file:read_file(TestLog)), %% now we've written enough bytes - lager:log(error, self(), "Test messageis64bytes"), + eRum:log(error, self(), "Test messageis64bytes"), {ok, Bin} = file:read_file(TestLog), ?assert(<<>> /= Bin) end}, @@ -878,14 +878,14 @@ filesystem_test_() -> gen_event:add_handler(lager_event, {lager_file_backend, TestLog}, {TestLog, info}), ?assertEqual(0, lager_test_backend:count()), - lager:log(info, self(), "Test message1"), - lager:log(error, self(), "Test message2"), + eRum:log(info, self(), "Test message1"), + eRum:log(error, self(), "Test message2"), {ok, Bin} = file:read_file(TestLog), Lines = length(re:split(Bin, "\n", [{return, list}, trim])), ?assertEqual(Lines, 2), - ?assertEqual(ok, lager:set_loglevel(lager_file_backend, TestLog, warning)), - lager:log(info, self(), "Test message3"), %% this won't get logged - lager:log(error, self(), "Test message4"), + ?assertEqual(ok, eRum:set_loglevel(lager_file_backend, TestLog, warning)), + eRum:log(info, self(), "Test message3"), %% this won't get logged + eRum:log(error, self(), "Test message4"), {ok, Bin2} = file:read_file(TestLog), Lines2 = length(re:split(Bin2, "\n", [{return, list}, trim])), ?assertEqual(Lines2, 3) @@ -899,7 +899,7 @@ filesystem_test_() -> gen_event:add_handler(lager_event, lager_file_backend, [{TestLog, info, 10*1024*1024, "$D0", 5}, {lager_default_formatter}]), gen_event:add_handler(lager_event, lager_file_backend, {TestLog3, info}), - ?assertEqual({error, bad_module}, lager:set_loglevel(lager_file_backend, TestLog, warning)) + ?assertEqual({error, bad_module}, eRum:set_loglevel(lager_file_backend, TestLog, warning)) end}, {"tracing should work", fun() -> @@ -907,12 +907,12 @@ filesystem_test_() -> TestLog = filename:join(TestDir, "test.log"), gen_event:add_handler(lager_event, lager_file_backend, {TestLog, critical}), - lager:error("Test message"), + eRum:error("Test message"), ?assertEqual({ok, <<>>}, file:read_file(TestLog)), {Level, _} = lager_config:get({lager_event, loglevel}), lager_config:set({lager_event, loglevel}, {Level, [{[{module, ?MODULE}], ?DEBUG, {lager_file_backend, TestLog}}]}), - lager:error("Test message"), + eRum:error("Test message"), timer:sleep(1000), {ok, Bin} = file:read_file(TestLog), ?assertMatch([_, _, "[error]", _, "Test message\n"], @@ -932,7 +932,7 @@ filesystem_test_() -> gen_event:add_handler(lager_event, lager_file_backend, [{file, TestLog}, {level, critical}, {check_interval, always}]), timer:sleep(500), - lager:critical("Test message"), + eRum:critical("Test message"), {ok, Bin1} = file:read_file(TestLog), ?assertMatch([_, _, "[critical]", _, "Test message\n"], re:split(Bin1, " ", [{return, list}, {parts, 5}])), @@ -940,12 +940,12 @@ filesystem_test_() -> {Level, _} = lager_config:get({lager_event, loglevel}), lager_config:set({lager_event, loglevel}, {Level, [{[{module, ?MODULE}], ?DEBUG, {lager_file_backend, TestLog}}]}), - lager:critical("Test message"), + eRum:critical("Test message"), {ok, Bin2} = file:read_file(TestLog), ?assertMatch([_, _, "[critical]", _, "Test message\n"], re:split(Bin2, " ", [{return, list}, {parts, 5}])), ?assertEqual(ok, file:delete(TestLog)), - lager:error("Test message"), + eRum:error("Test message"), {ok, Bin3} = file:read_file(TestLog), ?assertMatch([_, _, "[error]", _, "Test message\n"], re:split(Bin3, " ", [{return, list}, {parts, 5}])) @@ -956,10 +956,10 @@ filesystem_test_() -> {ok, TestDir} = rumUtil:get_test_dir(), TestLog = filename:join(TestDir, "foo.log"), - {ok, _} = lager:trace_file(TestLog, [{module, ?MODULE}]), - lager:error("Test message"), + {ok, _} = eRum:trace_file(TestLog, [{module, ?MODULE}]), + eRum:error("Test message"), %% not eligible for trace - lager:log(error, self(), "Test message"), + eRum:log(error, self(), "Test message"), {ok, Bin3} = file:read_file(TestLog), ?assertMatch([_, _, "[error]", _, "Test message\n"], re:split(Bin3, " ", [{return, list}, {parts, 5}])) @@ -971,10 +971,10 @@ filesystem_test_() -> LogPath = filename:join(TestDir, LogName), application:set_env(lager, log_root, TestDir), - {ok, _} = lager:trace_file(LogName, [{module, ?MODULE}]), - lager:error("Test message"), + {ok, _} = eRum:trace_file(LogName, [{module, ?MODULE}]), + eRum:error("Test message"), %% not eligible for trace - lager:log(error, self(), "Test message"), + eRum:log(error, self(), "Test message"), {ok, Bin3} = file:read_file(LogPath), application:unset_env(lager, log_root), ?assertMatch([_, _, "[error]", _, "Test message\n"], @@ -986,16 +986,16 @@ filesystem_test_() -> TestLog = filename:join(TestDir, "foo.log"), TestLog0 = TestLog ++ ".0", - {ok, _} = lager:trace_file(TestLog, [{module, ?MODULE}], + {ok, _} = eRum:trace_file(TestLog, [{module, ?MODULE}], [{size, 20}, {check_interval, 1}]), - lager:error("Test message"), + eRum:error("Test message"), ?assertNot(filelib:is_regular(TestLog0)), %% rotation is sensitive to intervals between %% writes so we sleep to exceed the 1 %% millisecond interval specified by %% check_interval above timer:sleep(2), - lager:error("Test message"), + eRum:error("Test message"), timer:sleep(10), ?assert(filelib:is_regular(TestLog0)) end}, @@ -1009,7 +1009,7 @@ filesystem_test_() -> {_, _, MS} = os:timestamp(), % start close to the beginning of a new second ?assertEqual(ok, timer:sleep((1000000 - MS) div 1000 + 1)), - [lager:log(info, self(), "Foo ~p", [K]) || K <- lists:seq(1, MsgCount)], + [eRum:log(info, self(), "Foo ~p", [K]) || K <- lists:seq(1, MsgCount)], ?assertEqual(MsgCount, lager_test_backend:count()), % Note: bumped from 1000 to 1250 to ensure delayed write flushes to disk ?assertEqual(ok, timer:sleep(1250)), @@ -1047,7 +1047,7 @@ trace_files_test_() -> } ]), ok = application:set_env(lager, async_threshold, undefined), - ok = lager:start(), + ok = eRum:start(), {Log, Debug, Events} end, fun({_, _, _}) -> @@ -1060,10 +1060,10 @@ trace_files_test_() -> fun({Log, Debug, Events}) -> {"a trace using file backend set up in configuration should work", fun() -> - lager:error("trace test error message"), - lager:info("info message"), + eRum:error("trace test error message"), + eRum:info("info message"), %% not eligible for trace - lager:log(error, self(), "Not trace test message"), + eRum:log(error, self(), "Not trace test message"), {ok, BinInfo} = file:read_file(Events), ?assertMatch([_, _, "[error]", _, "trace test error message\n"], re:split(BinInfo, " ", [{return, list}, {parts, 5}])), @@ -1106,7 +1106,7 @@ formatting_test_() -> ok = rumUtil:safe_application_load(lager), ok = application:set_env(lager, handlers, [{lager_test_backend, info}]), ok = application:set_env(lager, error_logger_redirect, false), - ok = lager:start(), + ok = eRum:start(), %% same race condition issue ok = timer:sleep(5), {ok, Log1, Log2} @@ -1124,7 +1124,7 @@ formatting_test_() -> [{Log1, debug}, {lager_default_formatter, ["[",severity,"] ", message, "\n"]}]), gen_event:add_handler(lager_event, lager_file_backend, [{Log2, debug}, {lager_default_formatter, ["2> [",severity,"] ", message, "\n"]}]), - lager:log(error, self(), "Test message"), + eRum:log(error, self(), "Test message"), ?assertMatch({ok, <<"[error] Test message\n">>},file:read_file(Log1)), ?assertMatch({ok, <<"2> [error] Test message\n">>},file:read_file(Log2)) end} diff --git a/src/lager_handler_watcher.erl b/src/misc/lager_handler_watcher.erl similarity index 96% rename from src/lager_handler_watcher.erl rename to src/misc/lager_handler_watcher.erl index dc36282..77a35ee 100644 --- a/src/lager_handler_watcher.erl +++ b/src/misc/lager_handler_watcher.erl @@ -79,7 +79,7 @@ handle_info({gen_event_EXIT, Module, {'EXIT', {kill_me, [_KillerHWM, KillerReins {stop, normal, State}; handle_info({gen_event_EXIT, Module, Reason}, #state{module=Module, config=Config, sink=Sink} = State) -> - case lager:log(error, self(), "Lager event handler ~p exited with reason ~s", + case eRum:log(error, self(), "Lager event handler ~p exited with reason ~s", [Module, error_logger_lager_h:format_reason(Reason)]) of ok -> install_handler(Sink, Module, Config); @@ -125,7 +125,7 @@ install_handler2(Sink, Module, Config) -> case gen_event:add_sup_handler(Sink, Module, Config) of ok -> ?INT_LOG(debug, "Lager installed handler ~p into ~p", [Module, Sink]), - lager:update_loglevel_config(Sink), + eRum:update_loglevel_config(Sink), ok; {error, {fatal, Reason}} -> ?INT_LOG(error, "Lager fatally failed to install handler ~p into" @@ -156,7 +156,7 @@ reinstall_on_initial_failure_test_() -> application:set_env(lager, handlers, [{lager_test_backend, info}, {lager_crash_backend, [from_now(2), undefined]}]), application:set_env(lager, error_logger_redirect, false), application:unset_env(lager, crash_log), - lager:start(), + eRum:start(), try {_Level, _Time, Message, _Metadata} = lager_test_backend:pop(), ?assertMatch("Lager failed to install handler lager_crash_backend into lager_event, retrying later :"++_, lists:flatten(Message)), @@ -182,7 +182,7 @@ reinstall_on_runtime_failure_test_() -> application:set_env(lager, handlers, [{lager_test_backend, info}, {lager_crash_backend, [undefined, from_now(5)]}]), application:set_env(lager, error_logger_redirect, false), application:unset_env(lager, crash_log), - lager:start(), + eRum:start(), try ?assert(lists:member(lager_crash_backend, gen_event:which_handlers(lager_event))), timer:sleep(6000), @@ -210,8 +210,8 @@ reinstall_handlers_after_killer_hwm_test_() -> application:set_env(lager, error_logger_redirect, false), application:set_env(lager, killer_reinstall_after, 5000), application:unset_env(lager, crash_log), - lager:start(), - lager:trace_file("foo", [{foo, "bar"}], error), + eRum:start(), + eRum:trace_file("foo", [{foo, "bar"}], error), L = length(gen_event:which_handlers(lager_event)), try lager_manager_killer:kill_me(), diff --git a/src/lager_handler_watcher_sup.erl b/src/misc/lager_handler_watcher_sup.erl similarity index 100% rename from src/lager_handler_watcher_sup.erl rename to src/misc/lager_handler_watcher_sup.erl diff --git a/src/lager_manager_killer.erl b/src/misc/lager_manager_killer.erl similarity index 100% rename from src/lager_manager_killer.erl rename to src/misc/lager_manager_killer.erl diff --git a/src/lager_msg.erl b/src/misc/lager_msg.erl similarity index 83% rename from src/lager_msg.erl rename to src/misc/lager_msg.erl index e7d7dac..23b9bf4 100644 --- a/src/lager_msg.erl +++ b/src/misc/lager_msg.erl @@ -12,7 +12,7 @@ -record(lager_msg,{ destinations :: list(), metadata :: [tuple()], - severity :: lager:log_level(), + severity :: eRum:log_level(), datetime :: {string(), string()}, timestamp :: erlang:timestamp(), message :: list() @@ -22,13 +22,13 @@ -export_type([lager_msg/0]). %% create with provided timestamp, handy for testing mostly --spec new(list(), erlang:timestamp(), lager:log_level(), [tuple()], list()) -> lager_msg(). +-spec new(list(), erlang:timestamp(), eRum:log_level(), [tuple()], list()) -> lager_msg(). new(Msg, Timestamp, Severity, Metadata, Destinations) -> {Date, Time} = rumUtil:format_time(rumUtil:maybe_utc(rumUtil:localtime_ms(Timestamp))), #lager_msg{message=Msg, datetime={Date, Time}, timestamp=Timestamp, severity=Severity, metadata=Metadata, destinations=Destinations}. --spec new(list(), lager:log_level(), [tuple()], list()) -> lager_msg(). +-spec new(list(), eRum:log_level(), [tuple()], list()) -> lager_msg(). new(Msg, Severity, Metadata, Destinations) -> Now = os:timestamp(), new(Msg, Now, Severity, Metadata, Destinations). @@ -45,11 +45,11 @@ timestamp(Msg) -> datetime(Msg) -> Msg#lager_msg.datetime. --spec severity(lager_msg()) -> lager:log_level(). +-spec severity(lager_msg()) -> eRum:log_level(). severity(Msg) -> Msg#lager_msg.severity. --spec severity_as_int(lager_msg()) -> lager:log_level_number(). +-spec severity_as_int(lager_msg()) -> eRum:log_level_number(). severity_as_int(Msg) -> rumUtil:level_to_num(Msg#lager_msg.severity). diff --git a/src/lager_stdlib.erl b/src/misc/lager_stdlib.erl similarity index 100% rename from src/lager_stdlib.erl rename to src/misc/lager_stdlib.erl diff --git a/src/lager_trunc_io.erl b/src/misc/lager_trunc_io.erl similarity index 100% rename from src/lager_trunc_io.erl rename to src/misc/lager_trunc_io.erl diff --git a/src/rumUtil.erl b/src/misc/rumUtil.erl similarity index 99% rename from src/rumUtil.erl rename to src/misc/rumUtil.erl index b193570..0a55c59 100644 --- a/src/rumUtil.erl +++ b/src/misc/rumUtil.erl @@ -82,7 +82,7 @@ config_to_mask(Conf) -> level_to_num(Level) bor Acc end, 0, Levels)}. --spec mask_to_levels(non_neg_integer()) -> [lager:log_level()]. +-spec mask_to_levels(non_neg_integer()) -> [eRum:log_level()]. mask_to_levels(Mask) -> mask_to_levels(Mask, levels(), []). @@ -97,7 +97,7 @@ mask_to_levels(Mask, [Level|Levels], Acc) -> end, mask_to_levels(Mask, Levels, NewAcc). --spec config_to_levels(atom()|string()) -> [lager:log_level()]. +-spec config_to_levels(atom()|string()) -> [eRum:log_level()]. config_to_levels(Conf) when is_atom(Conf) -> config_to_levels(atom_to_list(Conf)); config_to_levels([$! | Rest]) -> @@ -706,7 +706,7 @@ rotation_calculation_test() -> ok. check_trace_test() -> - lager:start(), + eRum:start(), trace_filter(none), %% match by module ?assertEqual([foo], check_traces([{module, ?MODULE}], ?EMERGENCY, [ diff --git a/src/lager_rotator_behaviour.erl b/src/rotator/lager_rotator_behaviour.erl similarity index 100% rename from src/lager_rotator_behaviour.erl rename to src/rotator/lager_rotator_behaviour.erl diff --git a/src/lager_rotator_default.erl b/src/rotator/lager_rotator_default.erl similarity index 100% rename from src/lager_rotator_default.erl rename to src/rotator/lager_rotator_default.erl diff --git a/src/lager_common_test_backend.erl b/src/test/lager_common_test_backend.erl similarity index 99% rename from src/lager_common_test_backend.erl rename to src/test/lager_common_test_backend.erl index 56cf772..d7530ba 100644 --- a/src/lager_common_test_backend.erl +++ b/src/test/lager_common_test_backend.erl @@ -45,7 +45,7 @@ bounce(Level) -> [ {lager_common_test_backend, [Level, false]} ]), - ok = lager:start(), + ok = eRum:start(), %% we care more about getting all of our messages here than being %% careful with the amount of memory that we're using. error_logger_lager_h:set_high_water(100000), diff --git a/src/lager_transform.erl b/src/transform/lager_transform.erl similarity index 100% rename from src/lager_transform.erl rename to src/transform/lager_transform.erl diff --git a/test/compress_pr_record_test.erl b/test/compress_pr_record_test.erl index 9f62c5b..1c6aad1 100644 --- a/test/compress_pr_record_test.erl +++ b/test/compress_pr_record_test.erl @@ -16,7 +16,7 @@ nested_record_test() -> A = #a{field1 = "Notice me senpai"}, - Pr_A = lager:pr(A, ?MODULE), - Pr_A_Comp = lager:pr(A, ?MODULE, [compress]), + Pr_A = eRum:pr(A, ?MODULE), + Pr_A_Comp = eRum:pr(A, ?MODULE, [compress]), ?assertMatch({'$lager_record', a, [{field1, "Notice me senpai"}, {field2, undefined} | _]}, Pr_A), ?assertEqual({'$lager_record', a, [{field1, "Notice me senpai"}]}, Pr_A_Comp). diff --git a/test/lager_manager_killer_test.erl b/test/lager_manager_killer_test.erl index 96199b0..5def89c 100644 --- a/test/lager_manager_killer_test.erl +++ b/test/lager_manager_killer_test.erl @@ -26,7 +26,7 @@ overload_test_() -> lager_config:set(async, true), Manager = whereis(lager_event), erlang:trace(all, true, [procs]), - [lager:info("~p'th message", [N]) || N <- lists:seq(1,KillerHWM+2)], + [eRum:info("~p'th message", [N]) || N <- lists:seq(1,KillerHWM+2)], Margin = 100, ok = confirm_manager_exit(Manager, Delay+Margin), ok = confirm_sink_reregister(lager_event, Margin), diff --git a/test/lager_metadata_whitelist_test.erl b/test/lager_metadata_whitelist_test.erl index 89bbcb6..d10198d 100644 --- a/test/lager_metadata_whitelist_test.erl +++ b/test/lager_metadata_whitelist_test.erl @@ -11,7 +11,7 @@ setup() -> ok = application:set_env(lager, handlers, [{lager_common_test_backend, info}]), ok = application:set_env(lager, error_logger_redirect, false), ok = application:unset_env(lager, traces), - ok = lager:start(), + ok = eRum:start(), ok = timer:sleep(250), ok. diff --git a/test/lager_rotate.erl b/test/lager_rotate.erl index 41facc8..72f4642 100644 --- a/test/lager_rotate.erl +++ b/test/lager_rotate.erl @@ -66,7 +66,7 @@ rotate_test_() -> ]}]), application:set_env(lager, error_logger_redirect, false), application:set_env(lager, async_threshold, undefined), - lager:start(), + eRum:start(), timer:sleep(1000), State end, @@ -79,12 +79,12 @@ rotate_test_() -> fun(State) -> {"Rotate single file", fun() -> - lager:log(error, self(), "Test message 1"), - lager:log(sink_event, error, self(), "Sink test message 1", []), - lager:rotate_handler({lager_file_backend, State#state.log1}), + eRum:log(error, self(), "Test message 1"), + eRum:log(sink_event, error, self(), "Sink test message 1", []), + eRum:rotate_handler({lager_file_backend, State#state.log1}), ok = wait_until(fun() -> filelib:is_regular(State#state.log1r) end, 10), - lager:log(error, self(), "Test message 2"), - lager:log(sink_event, error, self(), "Sink test message 2", []), + eRum:log(error, self(), "Test message 2"), + eRum:log(sink_event, error, self(), "Sink test message 2", []), {ok, File1} = file:read_file(State#state.log1), {ok, File2} = file:read_file(State#state.log2), @@ -107,12 +107,12 @@ rotate_test_() -> fun(State) -> {"Rotate sink", fun() -> - lager:log(error, self(), "Test message 1"), - lager:log(sink_event, error, self(), "Sink test message 1", []), - lager:rotate_sink(sink_event), + eRum:log(error, self(), "Test message 1"), + eRum:log(sink_event, error, self(), "Sink test message 1", []), + eRum:rotate_sink(sink_event), ok = wait_until(fun() -> filelib:is_regular(State#state.sinkr) end, 10), - lager:log(error, self(), "Test message 2"), - lager:log(sink_event, error, self(), "Sink test message 2", []), + eRum:log(error, self(), "Test message 2"), + eRum:log(sink_event, error, self(), "Sink test message 2", []), {ok, File1} = file:read_file(State#state.log1), {ok, File2} = file:read_file(State#state.log2), {ok, SinkFile} = file:read_file(State#state.sink), @@ -134,12 +134,12 @@ rotate_test_() -> fun(State) -> {"Rotate all", fun() -> - lager:log(error, self(), "Test message 1"), - lager:log(sink_event, error, self(), "Sink test message 1", []), - lager:rotate_all(), + eRum:log(error, self(), "Test message 1"), + eRum:log(sink_event, error, self(), "Sink test message 1", []), + eRum:rotate_all(), ok = wait_until(fun() -> filelib:is_regular(State#state.sinkr) end, 10), - lager:log(error, self(), "Test message 2"), - lager:log(sink_event, error, self(), "Sink test message 2", []), + eRum:log(error, self(), "Test message 2"), + eRum:log(sink_event, error, self(), "Sink test message 2", []), {ok, File1} = file:read_file(State#state.log1), {ok, File2} = file:read_file(State#state.log2), {ok, SinkFile} = file:read_file(State#state.sink), diff --git a/test/lager_test_backend.erl b/test/lager_test_backend.erl index b1968e7..590dd23 100644 --- a/test/lager_test_backend.erl +++ b/test/lager_test_backend.erl @@ -86,11 +86,11 @@ handle_call(get_loglevel, #state{level=Level} = State) -> handle_call({set_loglevel, Level}, State) -> {ok, ok, State#state{level= rumUtil:config_to_mask(Level)}}; 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), {ok, ok, 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), {ok, ok, State}; handle_call(_Request, State) -> @@ -170,7 +170,7 @@ print_bad_state(Sink) -> gen_event:call(Sink, ?MODULE, print_bad_state). 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_() -> {foreach, @@ -185,12 +185,12 @@ lager_test_() -> }, {"test sink not running", 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 }, {"logging works", fun() -> - lager:warning("test message"), + eRum:warning("test message"), ?assertEqual(1, count()), {Level, _Time, Message, _Metadata} = pop(), ?assertMatch(Level, rumUtil:level_to_num(warning)), @@ -210,7 +210,7 @@ lager_test_() -> }, {"unsafe logging works", fun() -> - lager:warning_unsafe("test message"), + eRum:warning_unsafe("test message"), ?assertEqual(1, count()), {Level, _Time, Message, _Metadata} = pop(), ?assertMatch(Level, rumUtil:level_to_num(warning)), @@ -220,7 +220,7 @@ lager_test_() -> }, {"logging with arguments works", fun() -> - lager:warning("test message ~p", [self()]), + eRum:warning("test message ~p", [self()]), ?assertEqual(1, count()), {Level, _Time, Message,_Metadata} = pop(), ?assertMatch(Level, rumUtil:level_to_num(warning)), @@ -240,7 +240,7 @@ lager_test_() -> }, {"unsafe logging with args works", fun() -> - lager:warning_unsafe("test message ~p", [self()]), + eRum:warning_unsafe("test message ~p", [self()]), ?assertEqual(1, count()), {Level, _Time, Message,_Metadata} = pop(), ?assertMatch(Level, rumUtil:level_to_num(warning)), @@ -252,7 +252,7 @@ lager_test_() -> fun() -> ?assertEqual(0, count()), begin - lager:warning("test message 2") + eRum:warning("test message 2") end, ?assertEqual(1, count()), ok @@ -261,7 +261,7 @@ lager_test_() -> {"logging works from inside a list comprehension", fun() -> ?assertEqual(0, count()), - [lager:warning("test message") || _N <- lists:seq(1, 10)], + [eRum:warning("test message") || _N <- lists:seq(1, 10)], ?assertEqual(10, count()), ok end @@ -269,7 +269,7 @@ lager_test_() -> {"logging works from a begin/end block inside a list comprehension", fun() -> ?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()), ok end @@ -277,7 +277,7 @@ lager_test_() -> {"logging works from a nested list comprehension", fun() -> ?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)], ?assertEqual(100, count()), ok @@ -286,8 +286,8 @@ lager_test_() -> {"logging with only metadata works", fun() -> ?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()), ok end @@ -298,12 +298,12 @@ lager_test_() -> Attr = [{a, alpha}, {b, beta}], Fmt = "format ~p", 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()), {_Level, _Time, Message, Metadata} = pop(), ?assertMatch([{a, alpha}, {b, beta}|_], Metadata), @@ -328,12 +328,12 @@ lager_test_() -> Attr = [{a, alpha}, {b, beta}], Fmt = "format ~p", 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()), {_Level, _Time, Message, Metadata} = pop(), ?assertMatch([{a, "alpha"}, {b, "beta"}|_], Metadata), @@ -358,12 +358,12 @@ lager_test_() -> put(attrs, [{a, alpha}, {b, beta}]), put(format, "format ~p"), 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()), {_Level, _Time, Message, Metadata} = pop(), ?assertMatch([{a, alpha}, {b, beta}|_], Metadata), @@ -386,12 +386,12 @@ lager_test_() -> fun() -> ?assertEqual(0, count()), 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()), {_Level, _Time, Message, Metadata} = pop(), ?assertMatch([{a, alpha}, {b, beta}|_], Metadata), @@ -414,159 +414,159 @@ lager_test_() -> {"log messages below the threshold are ignored", fun() -> ?assertEqual(0, count()), - lager:debug("this message will be ignored"), + eRum:debug("this message will be ignored"), ?assertEqual(0, count()), ?assertEqual(0, count_ignored()), 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(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)), - lager:debug("this message should be logged"), + eRum:debug("this message should be logged"), ?assertEqual(1, count()), ?assertEqual(1, count_ignored()), - ?assertEqual(debug, lager:get_loglevel(?MODULE)), + ?assertEqual(debug, eRum:get_loglevel(?MODULE)), ok end }, {"tracing works", fun() -> lager_config:set(loglevel, {element(2, rumUtil:config_to_mask(error)), []}), - ok = lager:info("hello world"), + ok = eRum:info("hello world"), ?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)), %% elegible for tracing - ok = lager:info("hello world"), + ok = eRum:info("hello world"), %% NOT elegible for tracing - ok = lager:log(info, [{pid, self()}], "hello world"), + ok = eRum:log(info, [{pid, self()}], "hello world"), ?assertEqual(1, count()), ok end }, {"tracing works with custom attributes", fun() -> - lager:set_loglevel(?MODULE, error), + eRum:set_loglevel(?MODULE, error), ?assertEqual({?ERROR bor ?CRITICAL bor ?ALERT bor ?EMERGENCY, []}, lager_config:get(loglevel)), 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()), - 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()), - 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()), - lager:clear_all_traces(), - lager:info([{requestid, 6}], "hello world"), + eRum:clear_all_traces(), + eRum:info([{requestid, 6}], "hello world"), ?assertEqual(2, count()), ok end }, {"tracing works with custom attributes and event stream processing", fun() -> - lager:set_loglevel(?MODULE, error), + eRum:set_loglevel(?MODULE, error), ?assertEqual({?ERROR bor ?CRITICAL bor ?ALERT bor ?EMERGENCY, []}, lager_config:get(loglevel)), 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()), - 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()), - 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()), - 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()), - 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()), - lager:clear_all_traces(), - lager:info([{requestid, 6}], "hello world"), + eRum:clear_all_traces(), + eRum:info([{requestid, 6}], "hello world"), ?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()), - 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()), - lager:info([{foo, baz}], "blarg"), + eRum:info([{foo, baz}], "blarg"), ?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()), - 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()), ok end }, {"tracing custom attributes works with event stream processing statistics and reductions", fun() -> - lager:set_loglevel(?MODULE, error), + eRum:set_loglevel(?MODULE, error), ?assertEqual({?ERROR bor ?CRITICAL bor ?ALERT bor ?EMERGENCY, []}, lager_config:get(loglevel)), 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()), - 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(6, ?RumDefTracer:info(output)), ?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(4, ?RumDefTracer:info(output)), ?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"}]}, {beta, '>', 2}]}, ?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()), ok end @@ -574,14 +574,14 @@ lager_test_() -> {"persistent traces work", fun() -> ?assertEqual(0, count()), - lager:debug([{foo, bar}], "hello world"), + eRum:debug([{foo, bar}], "hello world"), ?assertEqual(0, count()), application:stop(lager), application:set_env(lager, traces, [{lager_test_backend, [{foo, bar}], debug}]), - lager:start(), + eRum:start(), timer:sleep(5), flush(), - lager:debug([{foo, bar}], "hello world"), + eRum:debug([{foo, bar}], "hello world"), ?assertEqual(1, count()), application:unset_env(lager, traces), ok @@ -589,15 +589,15 @@ lager_test_() -> }, {"tracing honors loglevel", fun() -> - lager:set_loglevel(?MODULE, error), + eRum:set_loglevel(?MODULE, error), ?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()), - ok = lager:notice("hello world"), + ok = eRum:notice("hello world"), ?assertEqual(1, count()), - lager:stop_trace(T), - ok = lager:notice("hello world"), + eRum:stop_trace(T), + ok = eRum:notice("hello world"), ?assertEqual(1, count()), ok end @@ -610,23 +610,23 @@ lager_test_() -> {_, T0} = lager_config:get({Sink, loglevel}), StartGlobal = lager_config:global_get(handlers), ?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), - {ok, TestTrace2} = lager:trace_file("/tmp/test", [{c, d}]), + {ok, TestTrace2} = eRum:trace_file("/tmp/test", [{c, d}]), MidHandlers = gen_event:which_handlers(Sink), ?assertEqual(length(StartHandlers) + 1, length(MidHandlers)), MidGlobal = lager_config:global_get(handlers), ?assertEqual(length(StartGlobal)+1, length(MidGlobal)), {_, T1} = lager_config:get({Sink, loglevel}), ?assertEqual(2, length(T1)), - ok = lager:stop_trace(TestTrace1), + ok = eRum:stop_trace(TestTrace1), {_, T2} = lager_config:get({Sink, loglevel}), ?assertEqual(1, length(T2)), ?assertEqual(length(StartHandlers)+1, length( gen_event:which_handlers(Sink))), ?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), EndGlobal = lager_config:global_get(handlers), {_, T3} = lager_config:get({Sink, loglevel}), @@ -657,7 +657,7 @@ lager_test_() -> }, {"record printing fails gracefully when no lager_record attribute", 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), {Level, _Time, Message, _Metadata} = pop(), ?assertMatch(Level, rumUtil:level_to_num(info)), @@ -667,7 +667,7 @@ lager_test_() -> }, {"record printing fails gracefully when input is not a tuple", 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), {Level, _Time, Message, _Metadata} = pop(), ?assertMatch(Level, rumUtil:level_to_num(info)), @@ -677,7 +677,7 @@ lager_test_() -> }, {"record printing fails gracefully when module is invalid", 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), {Level, _Time, Message, _Metadata} = pop(), ?assertMatch(Level, rumUtil:level_to_num(info)), @@ -695,15 +695,15 @@ lager_test_() -> }, {"metadata in the process dictionary works", 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(), ?assertEqual(gravid, proplists:get_value(platypus, Metadata)), ?assertEqual(hirsute, proplists:get_value(sloth, Metadata)), ?assertEqual(erroneous, proplists:get_value(duck, 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(), ?assertEqual(gravid, proplists:get_value(platypus, Metadata2)), ?assertEqual(hirsute, proplists:get_value(sloth, Metadata2)), @@ -714,22 +714,22 @@ lager_test_() -> }, {"unsafe messages really are not truncated", 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(), ?assert(length(lists:flatten(Msg)) == 6035) end }, {"can't store invalid metadata", 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 end }, {"dates should be local by default", fun() -> - lager:warning("so long, and thanks for all the fish"), + eRum:warning("so long, and thanks for all the fish"), ?assertEqual(1, count()), {_Level, {_Date, Time}, _Message, _Metadata} = pop(), ?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", fun() -> 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), ?assertEqual(1, count()), {_Level, {_Date, Time}, _Message, _Metadata} = pop(), @@ -818,23 +818,23 @@ extra_sinks_test_() -> {_, T0} = lager_config:get({Sink, loglevel}), StartGlobal = lager_config:global_get(handlers), ?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), - {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), ?assertEqual(length(StartHandlers)+1, length(MidHandlers)), MidGlobal = lager_config:global_get(handlers), ?assertEqual(length(StartGlobal)+1, length(MidGlobal)), {_, T1} = lager_config:get({Sink, loglevel}), ?assertEqual(2, length(T1)), - ok = lager:stop_trace(TestTrace1), + ok = eRum:stop_trace(TestTrace1), {_, T2} = lager_config:get({Sink, loglevel}), ?assertEqual(1, length(T2)), ?assertEqual(length(StartHandlers)+1, length( gen_event:which_handlers(Sink))), ?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), EndGlobal = lager_config:global_get(handlers), {_, T3} = lager_config:get({Sink, loglevel}), @@ -854,12 +854,12 @@ extra_sinks_test_() -> ?TEST_SINK_NAME:debug("this message should be ignored"), ?assertEqual(0, count(?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})), ?TEST_SINK_NAME:debug("this message should be logged"), ?assertEqual(1, count(?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 end } @@ -872,7 +872,7 @@ setup_sink() -> application:set_env(lager, handlers, []), application:set_env(lager, error_logger_redirect, false), 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(?TEST_SINK_EVENT, ?MODULE, flush). @@ -882,7 +882,7 @@ setup() -> application:set_env(lager, handlers, [{?MODULE, info}]), application:set_env(lager, error_logger_redirect, false), application:unset_env(lager, traces), - lager:start(), + eRum:start(), %% 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 %% 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:set_env(lager, error_logger_redirect, true), application:set_env(lager, handlers, [{?MODULE, error}]), - lager:start(), + eRum:start(), crash:start(), lager_event. @@ -966,7 +966,7 @@ error_logger_redirect_crash_setup_sink() -> application:set_env(lager, extra_sinks, [ {error_logger_lager_event, [ {handlers, [{?MODULE, error}]}]}]), - lager:start(), + eRum:start(), crash:start(), error_logger_lager_event. @@ -985,10 +985,10 @@ crash_fsm_setup() -> application:load(lager), application:set_env(lager, error_logger_redirect, true), application:set_env(lager, handlers, [{?MODULE, error}]), - lager:start(), + eRum:start(), crash_fsm:start(), crash_statem:start(), - lager:log(error, self(), "flush flush"), + eRum:log(error, self(), "flush flush"), timer:sleep(100), gen_event:call(lager_event, ?MODULE, flush), lager_event. @@ -1000,10 +1000,10 @@ crash_fsm_sink_setup() -> application:set_env(lager, error_logger_redirect, true), application:set_env(lager, handlers, []), application:set_env(lager, extra_sinks, [{ErrorSink, [{handlers, [{?MODULE, error}]}]}]), - lager:start(), + eRum:start(), crash_fsm:start(), crash_statem:start(), - lager:log(ErrorSink, error, self(), "flush flush", []), + eRum:log(ErrorSink, error, self(), "flush flush", []), timer:sleep(100), flush(ErrorSink), ErrorSink. @@ -1140,8 +1140,8 @@ error_logger_redirect_setup() -> application:set_env(lager, handlers, [{?MODULE, info}]), application:set_env(lager, suppress_supervisor_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), gen_event:call(lager_event, ?MODULE, flush), lager_event. @@ -1156,8 +1156,8 @@ error_logger_redirect_setup_sink() -> {handlers, [{?MODULE, info}]}]}]), application:set_env(lager, suppress_supervisor_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), gen_event:call(error_logger_lager_event, ?MODULE, flush), error_logger_lager_event. @@ -1454,7 +1454,7 @@ error_logger_redirect_test_() -> }, {"supervisor progress report", 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})), sync_error_logger:info_report(progress, [{supervisor, {local, foo}}, {started, [{mfargs, {foo, bar, 1}}, {pid, baz}]}]), _ = gen_event:which_handlers(error_logger), @@ -1466,7 +1466,7 @@ error_logger_redirect_test_() -> }, {"supervisor progress report with pid", 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})), sync_error_logger:info_report(progress, [{supervisor, somepid}, {started, [{mfargs, {foo, bar, 1}}, {pid, baz}]}]), _ = 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", 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})), sync_error_logger:info_report([hello, world]), _ = gen_event:which_handlers(error_logger), ?assertEqual(0, count(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})), sync_error_logger:info_report([hello, world]), _ = gen_event:which_handlers(error_logger), ?assertEqual(1, count(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})), lager_config:set({Sink, loglevel}, {element(2, rumUtil:config_to_mask(debug)), []}), sync_error_logger:info_report([hello, world]), @@ -1734,13 +1734,13 @@ error_logger_redirect_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. 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. 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_window, 1), ok = application:set_env(lager, handlers, [{?MODULE, info}]), - ok = lager:start(), + ok = eRum:start(), true end, {foreach, Setup, Cleanup, [ @@ -1811,7 +1811,7 @@ async_threshold_test_() -> _ = gen_event:which_handlers(lager_event), timer:sleep(Sleep), - lager:info("hello world"), + eRum:info("hello world"), _ = gen_event:which_handlers(lager_event), timer:sleep(Sleep), @@ -1839,7 +1839,7 @@ message_stuffer(N, Level, Message) -> message_stuffer_(0, _, _, _) -> ok; message_stuffer_(N, Level, Meta, Message) -> - lager:log(Level, Meta, Message), + eRum:log(Level, Meta, Message), message_stuffer_((N - 1), Level, Meta, Message). collect_workers([]) -> @@ -1865,7 +1865,7 @@ high_watermark_test_() -> application:set_env(lager, error_logger_redirect, true), application:set_env(lager, handlers, [{lager_test_backend, info}]), application:set_env(lager, async_threshold, undefined), - lager:start() + eRum:start() end, fun(_) -> application:stop(lager), diff --git a/test/lager_test_function_transform.erl b/test/lager_test_function_transform.erl index d5bd0f4..89e2f3e 100644 --- a/test/lager_test_function_transform.erl +++ b/test/lager_test_function_transform.erl @@ -57,7 +57,7 @@ transform_dynamic() -> end. 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")). setup() -> ok = error_logger:tty(false), @@ -65,7 +65,7 @@ setup() -> ok = application:set_env(lager, handlers, [{lager_test_backend, info}]), ok = application:set_env(lager, error_logger_redirect, false), ok = application:unset_env(lager, traces), - ok = lager:start(), + ok = eRum:start(), %% 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 %% tests. When the lager start up message wins the race, it causes these tests @@ -99,7 +99,7 @@ transform_function_test_() -> }, {"logging works", fun() -> - lager:warning("test message"), + eRum:warning("test message"), ?assertEqual(1, lager_test_backend:count()), {Level, _Time, Message, _Metadata} = lager_test_backend:pop(), ?assertMatch(Level, rumUtil:level_to_num(warning)), @@ -109,7 +109,7 @@ transform_function_test_() -> }, {"Testing calling a function returns the same content on emit", fun() -> - lager:warning("static message"), + eRum:warning("static message"), ?assertEqual(1, lager_test_backend:count()), {_Level, _Time, _Message, Metadata} = lager_test_backend:pop(), Function = proplists:get_value(returns_static_emit, Metadata), @@ -119,7 +119,7 @@ transform_function_test_() -> }, {"Testing calling a function which returns content which can change on emit", fun() -> - lager:warning("dynamic message"), + eRum:warning("dynamic message"), ?assertEqual(1, lager_test_backend:count()), {_Level, _Time, _Message, Metadata} = lager_test_backend:pop(), Function = proplists:get_value(returns_dynamic_emit, Metadata), @@ -132,7 +132,7 @@ transform_function_test_() -> }, {"Testing a undefined function returns undefined on emit", fun() -> - lager:warning("Undefined error"), + eRum:warning("Undefined error"), ?assertEqual(1, lager_test_backend:count()), {_Level, _Time, _Message, Metadata} = lager_test_backend:pop(), Function = proplists:get_value(returns_undefined_emit, Metadata), @@ -143,7 +143,7 @@ transform_function_test_() -> }, {"Testing calling a function returns the same content on log", fun() -> - lager:warning("static message"), + eRum:warning("static message"), ?assertEqual(1, lager_test_backend:count()), {_Level, _Time, _Message, Metadata} = lager_test_backend:pop(), ?assertEqual(transform_static(), proplists:get_value(returns_static_log, Metadata)), @@ -152,7 +152,7 @@ transform_function_test_() -> }, {"Testing calling a dynamic function on log which returns the same value", fun() -> - lager:warning("dynamic message"), + eRum:warning("dynamic message"), ?assertEqual(1, lager_test_backend:count()), {_Level, _Time, _Message, Metadata} = lager_test_backend:pop(), Value = proplists:get_value(returns_dynamic_log, Metadata), @@ -166,7 +166,7 @@ transform_function_test_() -> }, {"Testing differences in results for on_log vs on emit from dynamic function", fun() -> - lager:warning("on_log vs on emit"), + eRum:warning("on_log vs on emit"), ?assertEqual(1, lager_test_backend:count()), {_Level, _Time, _Message, Metadata} = lager_test_backend:pop(), Value = proplists:get_value(returns_dynamic_log, Metadata), @@ -183,8 +183,8 @@ transform_function_test_() -> Provided = fun() -> provided_metadata end, - lager:md([{provided, Provided}]), - lager:warning("Provided metadata"), + eRum:md([{provided, Provided}]), + eRum:warning("Provided metadata"), ?assertEqual(1, lager_test_backend:count()), {_Level, _Time, _Message, Metadata} = lager_test_backend:pop(), Function = proplists:get_value(provided, Metadata), diff --git a/test/lager_trace_test.erl b/test/lager_trace_test.erl index 48d722d..08087a8 100644 --- a/test/lager_trace_test.erl +++ b/test/lager_trace_test.erl @@ -35,7 +35,7 @@ trace_test_() -> [{tag, mytag}], info}]), application:set_env(lager, error_logger_redirect, false), application:set_env(lager, async_threshold, undefined), - lager:start() + eRum:start() end, fun(_) -> file:delete(?FNAME), @@ -50,7 +50,7 @@ trace_test_() -> end, [{"Trace combined with log_root", fun() -> - lager:info([{tag, mytag}], "Test message"), + eRum:info([{tag, mytag}], "Test message"), % Wait until we have the expected log entry in the log file. case wait_until(fun() -> diff --git a/test/pr_composite_test.erl b/test/pr_composite_test.erl index 66807bf..c01be6f 100644 --- a/test/pr_composite_test.erl +++ b/test/pr_composite_test.erl @@ -11,7 +11,7 @@ nested_record_test() -> A = #a{field1 = x, field2 = y}, B = #b{field1 = A, field2 = {}}, - Pr_B = lager:pr(B, ?MODULE), + Pr_B = eRum:pr(B, ?MODULE), ?assertEqual({'$lager_record', b, [{field1, {'$lager_record', a, [{field1, x},{field2, y}]}}, @@ -22,7 +22,7 @@ list_field_test() -> As = [#a{field1 = 1, field2 = a2}, #a{field1 = 2, field2 = a2}], B = #b{field1 = As, field2 = b2}, - Pr_B = lager:pr(B, ?MODULE), + Pr_B = eRum:pr(B, ?MODULE), ?assertEqual({'$lager_record', b, [{field1, [{'$lager_record', a, [{field1, 1},{field2, a2}]}, @@ -34,14 +34,14 @@ list_field_test() -> list_of_records_test() -> As = [#a{field1 = 1, field2 = a2}, #a{field1 = 2, field2 = a2}], - Pr_As = lager:pr(As, ?MODULE), + Pr_As = eRum:pr(As, ?MODULE), ?assertEqual([{'$lager_record', a, [{field1, 1},{field2, a2}]}, {'$lager_record', a, [{field1, 2},{field2, a2}]}], Pr_As). improper_list_test() -> A = #a{field1 = [1|2], field2 = a2}, - Pr_A = lager:pr(A, ?MODULE), + Pr_A = eRum:pr(A, ?MODULE), ?assertEqual({'$lager_record',a, [{field1,[1|2]},{field2,a2}]}, Pr_A). diff --git a/test/pr_stacktrace_test.erl b/test/pr_stacktrace_test.erl index 2853a22..711a583 100644 --- a/test/pr_stacktrace_test.erl +++ b/test/pr_stacktrace_test.erl @@ -26,7 +26,7 @@ pr_stacktrace_throw_test() -> make_throw() catch ?EXCEPTION(Class, Reason, Stacktrace) -> - lager:pr_stacktrace(?GET_STACK(Stacktrace), {Class, Reason}) + eRum:pr_stacktrace(?GET_STACK(Stacktrace), {Class, Reason}) end, Want = "pr_stacktrace_test:pr_stacktrace_throw_test/0 line 26\n pr_stacktrace_test:make_throw/0 line 16\nthrow:{test,exception}", ?assertNotEqual(nomatch, string:find(Got, Want)). @@ -36,7 +36,7 @@ pr_stacktrace_bad_arg_test() -> bad_arg() catch ?EXCEPTION(Class, Reason, Stacktrace) -> - lager:pr_stacktrace(?GET_STACK(Stacktrace), {Class, Reason}) + eRum:pr_stacktrace(?GET_STACK(Stacktrace), {Class, Reason}) end, Want = "pr_stacktrace_test:pr_stacktrace_bad_arg_test/0 line 36\n pr_stacktrace_test:bad_arg/0 line 22\nerror:badarg", ?assertNotEqual(nomatch, string:find(Got, Want)). @@ -46,7 +46,7 @@ pr_stacktrace_bad_arity_test() -> bad_arity() catch ?EXCEPTION(Class, Reason, Stacktrace) -> - lager:pr_stacktrace(?GET_STACK(Stacktrace), {Class, Reason}) + eRum:pr_stacktrace(?GET_STACK(Stacktrace), {Class, Reason}) end, Want = "pr_stacktrace_test:pr_stacktrace_bad_arity_test/0 line 46\n lists:concat([], [])\nerror:undef", ?assertNotEqual(nomatch, string:find(Got, Want)). @@ -57,7 +57,7 @@ pr_stacktrace_no_reverse_test() -> bad_arity() catch ?EXCEPTION(Class, Reason, Stacktrace) -> - lager:pr_stacktrace(?GET_STACK(Stacktrace), {Class, Reason}) + eRum:pr_stacktrace(?GET_STACK(Stacktrace), {Class, Reason}) end, Want = "error:undef\n lists:concat([], [])\n pr_stacktrace_test:pr_stacktrace_bad_arity_test/0 line 57", ?assertEqual(nomatch, string:find(Got, Want)). diff --git a/test/zzzz_gh280_crash.erl b/test/zzzz_gh280_crash.erl index c384dc6..064aa1a 100644 --- a/test/zzzz_gh280_crash.erl +++ b/test/zzzz_gh280_crash.erl @@ -19,7 +19,7 @@ gh280_impl() -> %% see https://github.com/erlang/otp/blob/maint/lib/stdlib/src/log_mf_h.erl#L81 %% for an explanation of the init arguments to log_mf_h ok = gen_event:add_sup_handler(error_logger, log_mf_h, log_mf_h:init("/tmp", 10000, 5)), - lager:start(), + eRum:start(), Result = receive {gen_event_EXIT,log_mf_h,normal} -> true;