ft:修改

include/rum.hrl

@@ -1,6 +1,6 @@
 -define(RumDefTruncation, 4096).
 -define(RumDefTracer, lager_default_tracer).
--define(RumDefSink, lager_event).
+-define(RumDefSink, rumEvent).
 -define(RumErrLogSink, error_logger_lager_event).
 
 -define(RumMetadata(Extras), [
@@ -59,7 +59,7 @@
 -define(RunShouldLog(Level), (rumUtil:level_to_num(Level) band element(1, rumConfig:get(loglevel, {?LOG_NONE, []}))) /= 0).
 
 -define(RunNotify(Level, Pid, Format, Args),
-   gen_event:notify(lager_event, {log, rumMsg:new(io_lib:format(Format, Args), Level, [{pid, Pid}, {line, ?LINE}, {file, ?FILE}, {module, ?MODULE}], [])})).
+   gen_event:notify(rumEvent, {log, rumMsg:new(io_lib:format(Format, Args), Level, [{pid, Pid}, {line, ?LINE}, {file, ?FILE}, {module, ?MODULE}], [])})).
 
 %%仅供内部使用仅内部非阻塞日志记录调用，当我们仍在启动大型啤酒时尝试进行日志记录（通常为错误）时，会有一些特殊处理。
 -ifdef(TEST).
@@ -76,7 +76,7 @@
    %% do this in a spawn so we don't cause a deadlock calling gen_event:which_handlers
    %% from a gen_event handler
    spawn(fun() ->
-      case catch (gen_event:which_handlers(lager_event)) of
+      case catch (gen_event:which_handlers(rumEvent)) of
          X when X == []; X == {'EXIT', noproc}; X == [lager_backend_throttle] ->
             %% there's no handlers yet or lager isn't running, try again
             %% in half a second.

src/backend/rumBackendThrottle.erl

@@ -1,19 +1,3 @@
-%% Copyright (c) 2011-2013 Basho Technologies, Inc.  All Rights Reserved.
-%%
-%% This file is provided to you under the Apache License,
-%% Version 2.0 (the "License"); you may not use this file
-%% except in compliance with the License.  You may obtain
-%% a copy of the License at
-%%
-%%   http://www.apache.org/licenses/LICENSE-2.0
-%%
-%% Unless required by applicable law or agreed to in writing,
-%% software distributed under the License is distributed on an
-%% "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-%% KIND, either express or implied.  See the License for the
-%% specific language governing permissions and limitations
-%% under the License.
-
 %% @doc A simple gen_event backend used to monitor mailbox size and
 %% switch log messages between synchronous and asynchronous modes.
 %% A gen_event handler is used because a process getting its own mailbox
@@ -22,23 +6,18 @@
 
 -module(rumBackendThrottle).
 
--include("rum.hrl").
-
 -behaviour(gen_event).
 
--export([init/1, handle_call/2, handle_event/2, handle_info/2, terminate/2,
-   code_change/3]).
+-include("rum.hrl").
 
-%%
-%% Allow test code to verify that we're doing the needful.
--ifdef(TEST).
--define(ETS_TABLE, async_threshold_test).
--define(TOGGLE_SYNC(), test_increment(sync_toggled)).
--define(TOGGLE_ASYNC(), test_increment(async_toggled)).
--else.
--define(TOGGLE_SYNC(), true).
--define(TOGGLE_ASYNC(), true).
--endif.
+-export([
+   init/1
+   , handle_call/2
+   , handle_event/2
+   , handle_info/2
+   , terminate/2,
+   code_change/3
+]).
 
 -record(state, {
    sink :: atom(),
@@ -51,7 +30,6 @@ init([{sink, Sink}, Hwm, Window]) ->
    rumConfig:set({Sink, async}, true),
    {ok, #state{sink = Sink, hwm = Hwm, window_min = Hwm - Window}}.
 
-
 handle_call(get_loglevel, State) ->
    {ok, {mask, ?LOG_NONE}, State};
 handle_call({set_loglevel, _Level}, State) ->
@@ -64,12 +42,10 @@ handle_event({log, _Message}, State) ->
    case {Len > State#state.hwm, Len < State#state.window_min, State#state.async} of
       {true, _, true} ->
          %% need to flip to sync mode
-         ?TOGGLE_SYNC(),
          rumConfig:set({State#state.sink, async}, false),
          {ok, State#state{async = false}};
       {_, true, false} ->
          %% need to flip to async mode
-         ?TOGGLE_ASYNC(),
          rumConfig:set({State#state.sink, async}, true),
          {ok, State#state{async = true}};
       _ ->
@@ -89,17 +65,3 @@ terminate(_Reason, _State) ->
 %% @private
 code_change(_OldVsn, State, _Extra) ->
    {ok, State}.
-
--ifdef(TEST).
-test_get(Key) ->
-   get_default(ets:lookup(?ETS_TABLE, Key)).
-
-test_increment(Key) ->
-   ets:insert(?ETS_TABLE,
-      {Key, test_get(Key) + 1}).
-
-get_default([]) ->
-   0;
-get_default([{_Key, Value}]) ->
-   Value.
--endif.

src/backend/rumConsoleBackend.erl

@@ -285,9 +285,9 @@ console_log_test_() ->
                Pid = spawn(F(self())),
                unregister(user),
                register(user, Pid),
-               erlang:group_leader(Pid, whereis(lager_event)),
-               gen_event:add_handler(lager_event, lager_console_backend, [{level, info}]),
-               rumConfig:set({lager_event, loglevel}, {element(2, rumUtil:config_to_mask(info)), []}),
+               erlang:group_leader(Pid, whereis(rumEvent)),
+               gen_event:add_handler(rumEvent, lager_console_backend, [{level, info}]),
+               rumConfig:set({rumEvent, loglevel}, {element(2, rumUtil:config_to_mask(info)), []}),
                eRum:log(info, self(), "Test message"),
                receive
                   {io_request, From, ReplyAs, {put_chars, unicode, Msg}} ->
@@ -305,9 +305,9 @@ console_log_test_() ->
                Pid = spawn(F(self())),
                unregister(user),
                register(user, Pid),
-               erlang:group_leader(Pid, whereis(lager_event)),
-               gen_event:add_handler(lager_event, lager_console_backend, [info, true]),
-               rumConfig:set({lager_event, loglevel}, {element(2, rumUtil:config_to_mask(info)), []}),
+               erlang:group_leader(Pid, whereis(rumEvent)),
+               gen_event:add_handler(rumEvent, lager_console_backend, [info, true]),
+               rumConfig:set({rumEvent, loglevel}, {element(2, rumUtil:config_to_mask(info)), []}),
                eRum:info("Test message"),
                PidStr = pid_to_list(self()),
                receive
@@ -325,11 +325,11 @@ console_log_test_() ->
                Pid = spawn(F(self())),
                unregister(user),
                register(user, Pid),
-               erlang:group_leader(Pid, whereis(lager_event)),
-               gen_event:add_handler(lager_event, lager_console_backend,
+               erlang:group_leader(Pid, whereis(rumEvent)),
+               gen_event:add_handler(rumEvent, lager_console_backend,
                   [{level, info}, {formatter, lager_default_formatter}, {formatter_config, [date, "#", time, "#", severity, "#", node, "#", pid, "#",
                      module, "#", function, "#", file, "#", line, "#", message, "\r\n"]}]),
-               rumConfig:set({lager_event, loglevel}, {?INFO, []}),
+               rumConfig:set({rumEvent, loglevel}, {?INFO, []}),
                eRum:info("Test message"),
                PidStr = pid_to_list(self()),
                NodeStr = atom_to_list(node()),
@@ -350,9 +350,9 @@ console_log_test_() ->
                Pid = spawn(F(self())),
                unregister(user),
                register(user, Pid),
-               gen_event:add_handler(lager_event, lager_console_backend, [{level, info}]),
-               erlang:group_leader(Pid, whereis(lager_event)),
-               rumConfig:set({lager_event, loglevel}, {element(2, rumUtil:config_to_mask(info)), []}),
+               gen_event:add_handler(rumEvent, lager_console_backend, [{level, info}]),
+               erlang:group_leader(Pid, whereis(rumEvent)),
+               rumConfig:set({rumEvent, loglevel}, {element(2, rumUtil:config_to_mask(info)), []}),
                eRum:debug("Test message"),
                receive
                   {io_request, From, ReplyAs, {put_chars, unicode, _Msg}} ->
@@ -380,9 +380,9 @@ console_log_test_() ->
                Pid = spawn(F(self())),
                unregister(user),
                register(user, Pid),
-               gen_event:add_handler(lager_event, lager_console_backend, [{level, info}]),
-               rumConfig:set({lager_event, loglevel}, {element(2, rumUtil:config_to_mask(info)), []}),
-               erlang:group_leader(Pid, whereis(lager_event)),
+               gen_event:add_handler(rumEvent, lager_console_backend, [{level, info}]),
+               rumConfig:set({rumEvent, loglevel}, {element(2, rumUtil:config_to_mask(info)), []}),
+               erlang:group_leader(Pid, whereis(rumEvent)),
                eRum:debug("Test message"),
                receive
                   {io_request, From, ReplyAs, {put_chars, unicode, _Msg}} ->
@@ -419,10 +419,10 @@ console_log_test_() ->
                Pid = spawn(F(self())),
                unregister(user),
                register(user, Pid),
-               gen_event:add_handler(lager_event, lager_console_backend, [{level, info}]),
-               rumConfig:set({lager_event, loglevel}, {element(2, rumUtil:config_to_mask(info)), []}),
+               gen_event:add_handler(rumEvent, lager_console_backend, [{level, info}]),
+               rumConfig:set({rumEvent, loglevel}, {element(2, rumUtil:config_to_mask(info)), []}),
                eRum:set_loglevel(lager_console_backend, '!=info'),
-               erlang:group_leader(Pid, whereis(lager_event)),
+               erlang:group_leader(Pid, whereis(rumEvent)),
                eRum:debug("Test message"),
                receive
                   {io_request, From1, ReplyAs1, {put_chars, unicode, Msg1}} ->
@@ -450,10 +450,10 @@ console_log_test_() ->
                Pid = spawn(F(self())),
                unregister(user),
                register(user, Pid),
-               gen_event:add_handler(lager_event, lager_console_backend, [{level, info}]),
-               rumConfig:set({lager_event, loglevel}, {element(2, rumUtil:config_to_mask(info)), []}),
+               gen_event:add_handler(rumEvent, lager_console_backend, [{level, info}]),
+               rumConfig:set({rumEvent, loglevel}, {element(2, rumUtil:config_to_mask(info)), []}),
                eRum:set_loglevel(lager_console_backend, '=debug'),
-               erlang:group_leader(Pid, whereis(lager_event)),
+               erlang:group_leader(Pid, whereis(rumEvent)),
                eRum:debug("Test message"),
                receive
                   {io_request, From1, ReplyAs1, {put_chars, unicode, Msg1}} ->
@@ -479,10 +479,10 @@ console_log_test_() ->
          {"console backend with custom group leader",
             fun() ->
                Pid = spawn(F(self())),
-               gen_event:add_handler(lager_event, lager_console_backend, [{level, info}, {group_leader, Pid}]),
-               rumConfig:set({lager_event, loglevel}, {element(2, rumUtil:config_to_mask(info)), []}),
+               gen_event:add_handler(rumEvent, lager_console_backend, [{level, info}, {group_leader, Pid}]),
+               rumConfig:set({rumEvent, loglevel}, {element(2, rumUtil:config_to_mask(info)), []}),
                eRum:info("Test message"),
-               ?assertNotEqual({group_leader, Pid}, erlang:process_info(whereis(lager_event), group_leader)),
+               ?assertNotEqual({group_leader, Pid}, erlang:process_info(whereis(rumEvent), group_leader)),
                receive
                   {io_request, From1, ReplyAs1, {put_chars, unicode, Msg1}} ->
                      From1 ! {io_reply, ReplyAs1, ok},
@@ -497,7 +497,7 @@ console_log_test_() ->
                exit(Pid, kill),
                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))),
+               ?assertNot(lists:member(lager_console_backend, gen_event:which_handlers(rumEvent))),
                eRum:error("Test message"),
                receive
                   {io_request, From2, ReplyAs2, {put_chars, unicode, _Msg2}} ->
@@ -514,12 +514,12 @@ console_log_test_() ->
                Pid = spawn(F(self())),
                ID = {?MODULE, trace_test},
                Handlers = rumConfig:global_get(handlers, []),
-               HandlerInfo = lager_app:start_handler(lager_event, ID,
+               HandlerInfo = lager_app:start_handler(rumEvent, ID,
                   [{level, none}, {group_leader, Pid},
                      {id, ID}]),
                rumConfig:global_set(handlers, [HandlerInfo | Handlers]),
                eRum:info("Test message"),
-               ?assertNotEqual({group_leader, Pid}, erlang:process_info(whereis(lager_event), group_leader)),
+               ?assertNotEqual({group_leader, Pid}, erlang:process_info(whereis(rumEvent), group_leader)),
                receive
                   {io_request, From, ReplyAs, {put_chars, unicode, _Msg}} ->
                      From ! {io_reply, ReplyAs, ok},
@@ -539,15 +539,15 @@ console_log_test_() ->
                   500 ->
                      ?assert(false)
                end,
-               ?assertNotEqual({0, []}, rumConfig:get({lager_event, loglevel})),
+               ?assertNotEqual({0, []}, rumConfig:get({rumEvent, loglevel})),
                %% killing the pid should prevent any new log messages (to prove we haven't accidentally redirected
                %% the group leader some other way
                exit(Pid, kill),
                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))),
+               ?assertNot(lists:member(lager_console_backend, gen_event:which_handlers(rumEvent))),
                %% finally, check the trace has been removed
-               ?assertEqual({0, []}, rumConfig:get({lager_event, loglevel})),
+               ?assertEqual({0, []}, rumConfig:get({rumEvent, loglevel})),
                eRum:error("Test message"),
                receive
                   {io_request, From3, ReplyAs3, {put_chars, unicode, _Msg3}} ->

src/backend/rumFileBackend.erl

@@ -611,7 +611,7 @@ filesystem_test_() ->
             {ok, TestDir} = rumUtil:get_test_dir(),
             TestLog = filename:join(TestDir, "test.log"),
 
-            gen_event:add_handler(lager_event, lager_file_backend,
+            gen_event:add_handler(rumEvent, lager_file_backend,
                [{TestLog, info}, {lager_default_formatter}]),
             eRum:log(error, self(), "Test message"),
             {ok, Bin} = file:read_file(TestLog),
@@ -624,7 +624,7 @@ filesystem_test_() ->
             {ok, TestDir} = rumUtil:get_test_dir(),
             TestLog = filename:join(TestDir, "test.log"),
 
-            gen_event:add_handler(lager_event, lager_file_backend,
+            gen_event:add_handler(rumEvent, lager_file_backend,
                [{TestLog, info}, {lager_default_formatter}]),
             eRum:log(error, self(), "~ts", [[20013, 25991, 27979, 35797]]),
             {ok, Bin} = file:read_file(TestLog),
@@ -639,7 +639,7 @@ filesystem_test_() ->
             TestLog = filename:join(TestDir, "test.log"),
 
             %% 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,
+            gen_event:add_handler(rumEvent, lager_file_backend,
                [{TestLog, info}, {lager_default_formatter}]),
             eRum:log(error, self(), "~ts", [[76, 198, 221, 206, 78, $-, 239]]),
             {ok, Bin} = file:read_file(TestLog),
@@ -658,7 +658,7 @@ filesystem_test_() ->
             FInfo1 = FInfo0#file_info{mode = 0},
             ?assertEqual(ok, file:write_file_info(TestLog, FInfo1)),
 
-            gen_event:add_handler(lager_event, lager_file_backend,
+            gen_event:add_handler(rumEvent, lager_file_backend,
                {TestLog, info, 10 * 1024 * 1024, "$D0", 5}),
 
             % Note: required on win32, do this early to prevent subsequent failures
@@ -683,7 +683,7 @@ filesystem_test_() ->
                   {ok, TestDir} = rumUtil:get_test_dir(),
                   TestLog = filename:join(TestDir, "test.log"),
 
-                  gen_event:add_handler(lager_event, lager_file_backend,
+                  gen_event:add_handler(rumEvent, lager_file_backend,
                      [{file, TestLog}, {level, info}, {check_interval, 0}]),
                   ?assertEqual(0, lager_test_backend:count()),
                   eRum:log(error, self(), "Test message"),
@@ -711,7 +711,7 @@ filesystem_test_() ->
             {ok, FInfo} = file:read_file_info(TestLog, [raw]),
             OldPerms = FInfo#file_info.mode,
             ?assertEqual(ok, file:write_file_info(TestLog, FInfo#file_info{mode = 0})),
-            gen_event:add_handler(lager_event, lager_file_backend,
+            gen_event:add_handler(rumEvent, lager_file_backend,
                [{file, TestLog}, {check_interval, 0}]),
             ?assertEqual(1, lager_test_backend:count()),
             {_Level, _Time, Message, _Metadata} = lager_test_backend:pop(),
@@ -737,7 +737,7 @@ filesystem_test_() ->
                   TestLog = filename:join(TestDir, "test.log"),
                   TestLog0 = TestLog ++ ".0",
 
-                  gen_event:add_handler(lager_event, lager_file_backend,
+                  gen_event:add_handler(rumEvent, lager_file_backend,
                      [{file, TestLog}, {level, info}, {check_interval, 0}]),
                   ?assertEqual(0, lager_test_backend:count()),
                   eRum:log(error, self(), "Test message1"),
@@ -764,7 +764,7 @@ filesystem_test_() ->
             TestLog = filename:join(TestDir, "test.log"),
             TestLog0 = TestLog ++ ".0",
 
-            gen_event:add_handler(lager_event, lager_file_backend,
+            gen_event:add_handler(rumEvent, lager_file_backend,
                [{file, TestLog}, {level, info}, {check_interval, 0}, {size, 10}]),
             eRum:log(error, self(), "Test message1"),
             eRum:log(error, self(), "Test message1"),
@@ -776,11 +776,11 @@ filesystem_test_() ->
             TestLog = filename:join(TestDir, "test.log"),
             TestLog0 = TestLog ++ ".0",
 
-            gen_event:add_handler(lager_event, lager_file_backend,
+            gen_event:add_handler(rumEvent, lager_file_backend,
                [{file, TestLog}, {level, info}, {check_interval, 1000}]),
             eRum:log(error, self(), "Test message1"),
             eRum:log(error, self(), "Test message1"),
-            whereis(lager_event) ! {rotate, TestLog},
+            whereis(rumEvent) ! {rotate, TestLog},
             eRum:log(error, self(), "Test message1"),
             ?assert(filelib:is_regular(TestLog0))
          end},
@@ -790,11 +790,11 @@ filesystem_test_() ->
             TestLog = filename:join(TestDir, "test.log"),
             TestLog0 = TestLog ++ ".0",
 
-            gen_event:add_handler(lager_event, {lager_file_backend, TestLog},
+            gen_event:add_handler(rumEvent, {lager_file_backend, TestLog},
                [{file, TestLog}, {level, info}, {check_interval, 1000}]),
             eRum:log(error, self(), "Test message1"),
             eRum:log(error, self(), "Test message1"),
-            gen_event:call(lager_event, {lager_file_backend, TestLog}, rotate, infinity),
+            gen_event:call(rumEvent, {lager_file_backend, TestLog}, rotate, infinity),
             eRum:log(error, self(), "Test message1"),
             ?assert(filelib:is_regular(TestLog0))
          end},
@@ -803,7 +803,7 @@ filesystem_test_() ->
             {ok, TestDir} = rumUtil:get_test_dir(),
             TestLog = filename:join(TestDir, "test.log"),
 
-            gen_event:add_handler(lager_event, lager_file_backend, [{file, TestLog},
+            gen_event:add_handler(rumEvent, lager_file_backend, [{file, TestLog},
                {level, info}, {sync_on, "=info"}, {check_interval, 5000}, {sync_interval, 5000}]),
             eRum:log(error, self(), "Test message1"),
             eRum:log(error, self(), "Test message1"),
@@ -817,7 +817,7 @@ filesystem_test_() ->
             {ok, TestDir} = rumUtil:get_test_dir(),
             TestLog = filename:join(TestDir, "test.log"),
 
-            gen_event:add_handler(lager_event, lager_file_backend, [{file, TestLog},
+            gen_event:add_handler(rumEvent, lager_file_backend, [{file, TestLog},
                {level, info}, {sync_on, "none"}, {check_interval, 5000}, {sync_interval, 1000}]),
             eRum:log(error, self(), "Test message1"),
             eRum:log(error, self(), "Test message1"),
@@ -833,7 +833,7 @@ filesystem_test_() ->
             {ok, TestDir} = rumUtil:get_test_dir(),
             TestLog = filename:join(TestDir, "test.log"),
 
-            gen_event:add_handler(lager_event, lager_file_backend, [{file, TestLog}, {level, info},
+            gen_event:add_handler(rumEvent, lager_file_backend, [{file, TestLog}, {level, info},
                {sync_on, "none"}, {check_interval, 5001}, {sync_size, 640}, {sync_interval, 5001}]),
             eRum:log(error, self(), "Test messageis64bytes"),
             eRum:log(error, self(), "Test messageis64bytes"),
@@ -856,7 +856,7 @@ filesystem_test_() ->
             {ok, TestDir} = rumUtil:get_test_dir(),
             TestLog = filename:join(TestDir, "test.log"),
 
-            gen_event:add_handler(lager_event, {lager_file_backend, TestLog}, {TestLog, info}),
+            gen_event:add_handler(rumEvent, {lager_file_backend, TestLog}, {TestLog, info}),
             ?assertEqual(0, lager_test_backend:count()),
             eRum:log(info, self(), "Test message1"),
             eRum:log(error, self(), "Test message2"),
@@ -876,9 +876,9 @@ filesystem_test_() ->
             TestLog = filename:join(TestDir, "test.log"),
             TestLog3 = filename:join(TestDir, "test3.log"),
 
-            gen_event:add_handler(lager_event, lager_file_backend,
+            gen_event:add_handler(rumEvent, lager_file_backend,
                [{TestLog, info, 10 * 1024 * 1024, "$D0", 5}, {lager_default_formatter}]),
-            gen_event:add_handler(lager_event, lager_file_backend, {TestLog3, info}),
+            gen_event:add_handler(rumEvent, lager_file_backend, {TestLog3, info}),
             ?assertEqual({error, bad_module}, eRum:set_loglevel(lager_file_backend, TestLog, warning))
          end},
       {"tracing should work",
@@ -886,11 +886,11 @@ filesystem_test_() ->
             {ok, TestDir} = rumUtil:get_test_dir(),
             TestLog = filename:join(TestDir, "test.log"),
 
-            gen_event:add_handler(lager_event, lager_file_backend, {TestLog, critical}),
+            gen_event:add_handler(rumEvent, lager_file_backend, {TestLog, critical}),
             eRum:error("Test message"),
             ?assertEqual({ok, <<>>}, file:read_file(TestLog)),
-            {Level, _} = rumConfig:get({lager_event, loglevel}),
-            rumConfig:set({lager_event, loglevel}, {Level,
+            {Level, _} = rumConfig:get({rumEvent, loglevel}),
+            rumConfig:set({rumEvent, loglevel}, {Level,
                [{[{module, ?MODULE}], ?DEBUG, {lager_file_backend, TestLog}}]}),
             eRum:error("Test message"),
             timer:sleep(1000),
@@ -909,7 +909,7 @@ filesystem_test_() ->
                   {ok, TestDir} = rumUtil:get_test_dir(),
                   TestLog = filename:join(TestDir, "test.log"),
 
-                  gen_event:add_handler(lager_event, lager_file_backend,
+                  gen_event:add_handler(rumEvent, lager_file_backend,
                      [{file, TestLog}, {level, critical}, {check_interval, always}]),
                   timer:sleep(500),
                   eRum:critical("Test message"),
@@ -917,8 +917,8 @@ filesystem_test_() ->
                   ?assertMatch([_, _, "[critical]", _, "Test message\n"],
                      re:split(Bin1, " ", [{return, list}, {parts, 5}])),
                   ?assertEqual(ok, file:delete(TestLog)),
-                  {Level, _} = rumConfig:get({lager_event, loglevel}),
-                  rumConfig:set({lager_event, loglevel},
+                  {Level, _} = rumConfig:get({rumEvent, loglevel}),
+                  rumConfig:set({rumEvent, loglevel},
                      {Level, [{[{module, ?MODULE}], ?DEBUG, {lager_file_backend, TestLog}}]}),
                   eRum:critical("Test message"),
                   {ok, Bin2} = file:read_file(TestLog),
@@ -984,7 +984,7 @@ filesystem_test_() ->
             MsgCount = 15,
             {ok, TestDir} = rumUtil:get_test_dir(),
             TestLog = filename:join(TestDir, "test.log"),
-            gen_event:add_handler(lager_event, lager_file_backend, [{file, TestLog}, {level, info},
+            gen_event:add_handler(rumEvent, lager_file_backend, [{file, TestLog}, {level, info},
                {high_water_mark, 5}, {flush_queue, false}, {sync_on, "=warning"}]),
             {_, _, MS} = os:timestamp(),
             % start close to the beginning of a new second
@@ -1100,9 +1100,9 @@ formatting_test_() ->
       fun({ok, Log1, Log2}) ->
          {"Should have two log files, the second prefixed with 2>",
             fun() ->
-               gen_event:add_handler(lager_event, lager_file_backend,
+               gen_event:add_handler(rumEvent, lager_file_backend,
                   [{Log1, debug}, {lager_default_formatter, ["[", severity, "] ", message, "\n"]}]),
-               gen_event:add_handler(lager_event, lager_file_backend,
+               gen_event:add_handler(rumEvent, lager_file_backend,
                   [{Log2, debug}, {lager_default_formatter, ["2> [", severity, "] ", message, "\n"]}]),
                eRum:log(error, self(), "Test message"),
                ?assertMatch({ok, <<"[error] Test message\n">>}, file:read_file(Log1)),

src/eRum.erl

@@ -135,7 +135,8 @@ do_log(Severity, Metadata, Format, Args, Size, SeverityAsInt, LevelThreshold, Tr
    do_log_impl(Severity, Metadata, Format, Args, SeverityAsInt, LevelThreshold, TraceFilters, Sink, SinkPid, FormatFun).
 
 do_log_impl(Severity, Metadata, Format, Args, SeverityAsInt, LevelThreshold, TraceFilters, Sink, SinkPid, FormatFun) ->
-   {Destinations, TraceSinkPid} = case TraceFilters of
+   {Destinations, TraceSinkPid} =
+      case TraceFilters of
                                      [] ->
                                         {[], undefined};
                                      _ ->
@@ -143,7 +144,8 @@ do_log_impl(Severity, Metadata, Format, Args, SeverityAsInt, LevelThreshold, Tra
                                   end,
    case (LevelThreshold band SeverityAsInt) /= 0 orelse Destinations /= [] of
       true ->
-         Msg = case Args of
+         Msg =
+            case Args of
                   A when is_list(A) ->
                      FormatFun();
                   _ ->
@@ -242,7 +244,8 @@ trace_file(File, Filter, Level, Options) ->
       {Sink, {ok, Trace}} ->
          Handlers = rumConfig:global_get(handlers, []),
          %% check if this file backend is already installed
-         Res = case rumUtil:find_file(FileName, Handlers) of
+         Res =
+            case rumUtil:find_file(FileName, Handlers) of
                   false ->
                      %% install the handler
                      LogFileConfig =

src/eRum_app.erl

@@ -13,12 +13,8 @@
    , boot/1
 ]).
 
-%% The `application:get_env/3` compatibility wrapper was useful
-%% for other modules in r15 and before
--export([get_env/3]).
-
 -define(FILENAMES, '__lager_file_backend_filenames').
--define(THROTTLE, lager_backend_throttle).
+-define(THROTTLE, rumBackendThrottle).
 -define(DEFAULT_HANDLER_CONF,
    [
       {lager_console_backend, [{level, info}]},
@@ -27,12 +23,7 @@
    ]).
 
 start() ->
-   application:start(lager).
-
-start_throttle(Sink, Threshold, Window) ->
-   _ = supervisor:start_child(lager_handler_watcher_sup,
-      [Sink, ?THROTTLE, [Threshold, Window]]),
-   ok.
+   application:start(eRum).
 
 determine_async_behavior(_Sink, undefined, _Window) ->
    ok;
@@ -40,12 +31,16 @@ determine_async_behavior(_Sink, Threshold, _Window) when not is_integer(Threshol
    error_logger:error_msg("Invalid value for 'async_threshold': ~p~n", [Threshold]),
    throw({error, bad_config});
 determine_async_behavior(Sink, Threshold, undefined) ->
-   start_throttle(Sink, Threshold, erlang:trunc(Threshold * 0.2));
+   startThrottle(Sink, Threshold, erlang:trunc(Threshold * 0.2));
 determine_async_behavior(_Sink, Threshold, Window) when not is_integer(Window) orelse Window > Threshold orelse Window < 0 ->
    error_logger:error_msg("Invalid value for 'async_threshold_window': ~p~n", [Window]),
    throw({error, bad_config});
 determine_async_behavior(Sink, Threshold, Window) ->
-   start_throttle(Sink, Threshold, Window).
+   startThrottle(Sink, Threshold, Window).
+
+startThrottle(Sink, Threshold, Window) ->
+   _ = supervisor:start_child(rumHandlerWatcherSup, [Sink, ?THROTTLE, [Threshold, Window]]),
+   ok.
 
 start_handlers(_Sink, undefined) ->
    ok;
@@ -175,29 +170,16 @@ maybe_remove_logger_handler() ->
 configure_sink(Sink, SinkDef) ->
    rumConfig:new_sink(Sink),
    ChildId = rumUtil:make_internal_sink_name(Sink),
-   _ = supervisor:start_child(eRum_sup,
-      {ChildId,
-         {gen_event, start_link,
-            [{local, Sink}]},
-         permanent, 5000, worker, dynamic}),
-   determine_async_behavior(Sink, proplists:get_value(async_threshold, SinkDef),
-      proplists:get_value(async_threshold_window, SinkDef)
-   ),
+   _ = supervisor:start_child(eRum_sup, {ChildId, {gen_event, start_link, [{local, Sink}]}, permanent, 5000, worker, dynamic}),
+   determine_async_behavior(Sink, proplists:get_value(async_threshold, SinkDef), proplists:get_value(async_threshold_window, SinkDef)),
    _ = maybe_install_sink_killer(Sink, proplists:get_value(killer_hwm, SinkDef),
       proplists:get_value(killer_reinstall_after, SinkDef)),
-   start_handlers(Sink,
-      proplists:get_value(handlers, SinkDef, [])),
-
+   start_handlers(Sink, proplists:get_value(handlers, SinkDef, [])),
    eRum:update_loglevel_config(Sink).
 
 
 configure_extra_sinks(Sinks) ->
-   lists:foreach(fun({Sink, Proplist}) -> configure_sink(Sink, Proplist) end,
-      Sinks).
-
--spec get_env(atom(), atom(), term()) -> term().
-get_env(Application, Key, Default) ->
-   application:get_env(Application, Key, Default).
+   lists:foreach(fun({Sink, Proplist}) -> configure_sink(Sink, Proplist) end, Sinks).
 
 start(_StartType, _StartArgs) ->
    {ok, Pid} = eRum_sup:start_link(),
@@ -209,15 +191,12 @@ start(_StartType, _StartArgs) ->
 
 boot() ->
    %% Handle the default sink.
-   determine_async_behavior(?RumDefSink,
-      application:get_env(lager, async_threshold, undefined),
-      application:get_env(lager, async_threshold_window, undefined)),
+   determine_async_behavior(?RumDefSink, application:get_env(lager, async_threshold, undefined), application:get_env(lager, async_threshold_window, undefined)),
 
    _ = maybe_install_sink_killer(?RumDefSink, application:get_env(lager, killer_hwm, undefined),
       application:get_env(lager, killer_reinstall_after, undefined)),
 
-   start_handlers(?RumDefSink,
-      application:get_env(lager, handlers, ?DEFAULT_HANDLER_CONF)),
+   start_handlers(?RumDefSink, application:get_env(lager, handlers, ?DEFAULT_HANDLER_CONF)),
 
    eRum:update_loglevel_config(?RumDefSink),
 

src/eRum_sup.erl

@@ -20,7 +20,7 @@ init([]) ->
    %%
    %% Maybe a new API to handle the sink and its policy?
    Children = [
-      {lager, {gen_event, start_link, [{local, lager_event}]}, permanent, 5000, worker, dynamic},
+      {lager, {gen_event, start_link, [{local, rumEvent}]}, permanent, 5000, worker, dynamic},
       {lager_handler_watcher_sup, {lager_handler_watcher_sup, start_link, []}, permanent, 5000, supervisor, [lager_handler_watcher_sup]}
    ],
 

src/misc/rumConfig.erl

@@ -21,7 +21,6 @@
 %% {{lager_event, loglevel}, Value} instead of {loglevel, Value}
 
 new() ->
-   init(),
    new_sink(?RumDefSink),
    %% Need to be able to find the `lager_handler_watcher' for all handlers
    insert_new({?GLOBAL, handlers}, []),
@@ -56,9 +55,6 @@ set({Sink, Key}, Value) ->
 set(Key, Value) ->
    set({?RumDefSink, Key}, Value).
 
-init() ->
-   ok.
-
 insert(Key, Value) ->
    persistent_term:put({?TBL, Key}, Value).
 

src/misc/rumMgrKiller.erl

@@ -14,7 +14,7 @@
 }).
 
 kill_me() ->
-   gen_event:call(lager_event, ?MODULE, kill_self).
+   gen_event:call(rumEvent, ?MODULE, kill_self).
 
 init([KillerHWM, KillerReinstallAfter]) ->
    {ok, #state{killer_hwm = KillerHWM, killer_reinstall_after = KillerReinstallAfter}}.

src/misc/rumUtil.erl

@@ -846,7 +846,7 @@ expand_path_test() ->
 
 sink_name_test_() ->
    [
-      ?_assertEqual(lager_event, make_internal_sink_name(lager)),
+      ?_assertEqual(rumEvent, make_internal_sink_name(lager)),
       ?_assertEqual(audit_lager_event, make_internal_sink_name(audit))
    ].
 

src/test/lager_common_test_backend.erl

@@ -33,7 +33,7 @@
 
 -spec get_logs() -> [iolist()] | {error, term()}.
 get_logs() ->
-   gen_event:call(lager_event, ?MODULE, get_logs, infinity).
+   gen_event:call(rumEvent, ?MODULE, get_logs, infinity).
 
 bounce() ->
    bounce(error).

src/watcher/rumHandlerWatcherSrv.erl

@@ -163,7 +163,7 @@ reinstall_on_initial_failure_test_() ->
                timer:sleep(6000),
                lager_test_backend:flush(),
                ?assertEqual(0, lager_test_backend:count()),
-               ?assert(lists:member(lager_crash_backend, gen_event:which_handlers(lager_event)))
+               ?assert(lists:member(lager_crash_backend, gen_event:which_handlers(rumEvent)))
             after
                application:stop(lager),
                application:stop(goldrush),
@@ -184,13 +184,13 @@ reinstall_on_runtime_failure_test_() ->
             application:unset_env(lager, crash_log),
             eRum:start(),
             try
-               ?assert(lists:member(lager_crash_backend, gen_event:which_handlers(lager_event))),
+               ?assert(lists:member(lager_crash_backend, gen_event:which_handlers(rumEvent))),
                timer:sleep(6000),
 
                pop_until("Lager event handler lager_crash_backend exited with reason crash", fun lists:flatten/1),
                pop_until("Lager failed to install handler lager_crash_backend into lager_event, retrying later",
                   fun(Msg) -> string:substr(lists:flatten(Msg), 1, 84) end),
-               ?assertEqual(false, lists:member(lager_crash_backend, gen_event:which_handlers(lager_event)))
+               ?assertEqual(false, lists:member(lager_crash_backend, gen_event:which_handlers(rumEvent)))
             after
                application:stop(lager),
                application:stop(goldrush),
@@ -212,11 +212,11 @@ reinstall_handlers_after_killer_hwm_test_() ->
             application:unset_env(lager, crash_log),
             eRum:start(),
             eRum:trace_file("foo", [{foo, "bar"}], error),
-            L = length(gen_event:which_handlers(lager_event)),
+            L = length(gen_event:which_handlers(rumEvent)),
             try
                rumMgrKiller:kill_me(),
                timer:sleep(6000),
-               ?assertEqual(L, length(gen_event:which_handlers(lager_event))),
+               ?assertEqual(L, length(gen_event:which_handlers(rumEvent))),
                file:delete("foo")
             after
                application:stop(lager),

test/lager_manager_killer_test.erl

@@ -24,21 +24,21 @@ overload_test_() ->
          application:set_env(lager, killer_reinstall_after, KillerReinstallAfter),
          ensure_started(lager),
          rumConfig:set(async, true),
-         Manager = whereis(lager_event),
+         Manager = whereis(rumEvent),
          erlang:trace(all, true, [procs]),
          [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),
+         ok = confirm_sink_reregister(rumEvent, Margin),
          erlang:trace(all, false, [procs]),
          wait_until(fun() ->
-            case proplists:get_value(lager_manager_killer, gen_event:which_handlers(lager_event)) of
+            case proplists:get_value(lager_manager_killer, gen_event:which_handlers(rumEvent)) of
                [] -> false;
                _ -> true
             end
                     end, Margin, 15),
          wait_until(fun() ->
-            case gen_event:call(lager_event, lager_manager_killer, get_settings) of
+            case gen_event:call(rumEvent, lager_manager_killer, get_settings) of
                [KillerHWM, KillerReinstallAfter] -> true;
                _Other -> false
             end

test/lager_test_backend.erl

@@ -122,28 +122,28 @@ code_change(_OldVsn, State, _Extra) ->
 -ifdef(TEST).
 
 pop() ->
-   pop(lager_event).
+   pop(rumEvent).
 
 pop_ignored() ->
-   pop_ignored(lager_event).
+   pop_ignored(rumEvent).
 
 get_buffer() ->
-   get_buffer(lager_event).
+   get_buffer(rumEvent).
 
 count() ->
-   count(lager_event).
+   count(rumEvent).
 
 count_ignored() ->
-   count_ignored(lager_event).
+   count_ignored(rumEvent).
 
 flush() ->
-   flush(lager_event).
+   flush(rumEvent).
 
 print_state() ->
-   print_state(lager_event).
+   print_state(rumEvent).
 
 print_bad_state() ->
-   print_bad_state(lager_event).
+   print_bad_state(rumEvent).
 
 pop(Sink) ->
    gen_event:call(Sink, ?MODULE, pop).
@@ -688,7 +688,7 @@ lager_test_() ->
          {"installing a new handler adjusts the global loglevel if necessary",
             fun() ->
                ?assertEqual({?INFO bor ?NOTICE bor ?WARNING bor ?ERROR bor ?CRITICAL bor ?ALERT bor ?EMERGENCY, []}, rumConfig:get(loglevel)),
-               supervisor:start_child(lager_handler_watcher_sup, [lager_event, {?MODULE, foo}, debug]),
+               supervisor:start_child(lager_handler_watcher_sup, [rumEvent, {?MODULE, foo}, debug]),
                ?assertEqual({?DEBUG bor ?INFO bor ?NOTICE bor ?WARNING bor ?ERROR bor ?CRITICAL bor ?ALERT bor ?EMERGENCY, []}, rumConfig:get(loglevel)),
                ok
             end
@@ -873,7 +873,7 @@ setup_sink() ->
    application:set_env(lager, error_logger_redirect, false),
    application:set_env(lager, extra_sinks, [{?TEST_SINK_EVENT, [{handlers, [{?MODULE, info}]}]}]),
    eRum:start(),
-   gen_event:call(lager_event, ?MODULE, flush),
+   gen_event:call(rumEvent, ?MODULE, flush),
    gen_event:call(?TEST_SINK_EVENT, ?MODULE, flush).
 
 setup() ->
@@ -897,7 +897,7 @@ setup() ->
    application:set_env(lager, suppress_supervisor_start_stop, true),
    application:set_env(lager, suppress_application_start_stop, true),
    timer:sleep(1000),
-   gen_event:call(lager_event, ?MODULE, flush).
+   gen_event:call(rumEvent, ?MODULE, flush).
 
 cleanup(_) ->
    catch ets:delete(lager_config), %% kill the ets config table with fire
@@ -956,7 +956,7 @@ error_logger_redirect_crash_setup() ->
    application:set_env(lager, handlers, [{?MODULE, error}]),
    eRum:start(),
    crash:start(),
-   lager_event.
+   rumEvent.
 
 error_logger_redirect_crash_setup_sink() ->
    error_logger:tty(false),
@@ -990,8 +990,8 @@ crash_fsm_setup() ->
    crash_statem:start(),
    eRum:log(error, self(), "flush flush"),
    timer:sleep(100),
-   gen_event:call(lager_event, ?MODULE, flush),
-   lager_event.
+   gen_event:call(rumEvent, ?MODULE, flush),
+   rumEvent.
 
 crash_fsm_sink_setup() ->
    ErrorSink = error_logger_lager_event,
@@ -1143,8 +1143,8 @@ error_logger_redirect_setup() ->
    eRum:start(),
    eRum:log(error, self(), "flush flush"),
    timer:sleep(1000),
-   gen_event:call(lager_event, ?MODULE, flush),
-   lager_event.
+   gen_event:call(rumEvent, ?MODULE, flush),
+   rumEvent.
 
 error_logger_redirect_setup_sink() ->
    error_logger:tty(false),
@@ -1791,7 +1791,7 @@ async_threshold_test_() ->
             Workers = spawn_stuffers(WorkCnt, [MsgCnt, info, "hello world"], []),
 
             %% serialize on mailbox
-            _ = gen_event:which_handlers(lager_event),
+            _ = gen_event:which_handlers(rumEvent),
             timer:sleep(Sleep),
 
             %% By now the flood of messages should have forced the backend throttle
@@ -1808,12 +1808,12 @@ async_threshold_test_() ->
             collect_workers(Workers),
 
             %% serialize on the mailbox again
-            _ = gen_event:which_handlers(lager_event),
+            _ = gen_event:which_handlers(rumEvent),
             timer:sleep(Sleep),
 
             eRum:info("hello world"),
 
-            _ = gen_event:which_handlers(lager_event),
+            _ = gen_event:which_handlers(rumEvent),
             timer:sleep(Sleep),
 
             %% async is true again now that the mailbox has drained

test/lager_test_function_transform.erl

@@ -78,7 +78,7 @@ setup() ->
    %% 4b5260c4524688b545cc12da6baa2dfa4f2afec9 which introduced the lager
    %% manager killer PR.
    ok = timer:sleep(250),
-   ok = gen_event:call(lager_event, lager_test_backend, flush).
+   ok = gen_event:call(rumEvent, lager_test_backend, flush).
 
 cleanup(_) ->
    catch ets:delete(lager_config), %% kill the ets config table with fire