ft: 代码整理

README.md

@@ -252,8 +252,8 @@ and for sinks:
 您可以使用以下配置指令来配置此行为：
 
 ```erlang
-{killer_hwm, 1000},
-{killer_reinstall_after, 5000}
+{killerHwm, 1000},
+{killerReTime, 5000}
 ```
 
 这意味着，如果接收器的邮箱大小超过1000条消息，请杀死整个接收器并在5000毫秒后重新加载它。如果需要，此行为也可以安装到其他水槽中。

eRum.sample.config

@@ -73,9 +73,9 @@
 
       %% **********************************************  killer相关  ****************************************************
       %% 如果接收器的邮箱大小超过1000条消息，请杀死整个接收器并在5000毫秒后重新加载它。如果需要，此行为也可以安装到其他水槽中。
-      {killer_hwm, 1000},
+      {killerHwm, 1000},
       %% 参见killer_hwm
-      {killer_reinstall_after, 5000},
+      {killerReTime, 5000},
 
       %% **********************************************  app启动停止监听相关  *********************************************
       %% 如果您不想在应用程序的调试级别看到主管和应用程序启动/停止日志，则可以使用以下配置将其关闭：

include/eRum.hrl

@@ -17,7 +17,7 @@
 -define(RumBackendThrottle, rumBackendThrottle).
 
 %% 默认日志文件选项
--define(DEFAULT_HANDLER_CONF,
+-define(RumDefHandler,
    [
       {lager_console_backend, [{level, info}]},
       {lager_file_backend, [{file, "error.log"}, {level, error}, {size, 10485760}, {date, "$D0"}, {count, 5}]},

src/eRum_app.erl

@@ -28,12 +28,11 @@ start(_StartType, _StartArgs) ->
 
 boot() ->
    %% Handle the default sink.
-   tryStartAsyncMgr(?RumDefSink, rumUtil:get_env(?RumAppName, asyncThreshold, undefined), rumUtil:get_env(?RumAppName, asyncThresholdWindow, undefined)),
+   tryStartAsyncMgr(rumUtil:get_env(asyncThreshold, undefined), rumUtil:get_env(asyncThresholdWindow, undefined), ?RumDefSink),
 
-   _ = maybe_install_sink_killer(?RumDefSink, application:get_env(lager, killer_hwm, undefined),
-      application:get_env(lager, killer_reinstall_after, undefined)),
+   tryInstallKiller(rumUtil:get_env(killerHwm, undefined), rumUtil:get_env(killerReTime, undefined), ?RumDefSink),
 
-   start_handlers(?RumDefSink, application:get_env(lager, handlers, ?DEFAULT_HANDLER_CONF)),
+   start_handlers(rumUtil:get_env(handlers, ?RumDefHandler), ?RumDefSink),
 
    eRum:update_loglevel_config(?RumDefSink),
 
@@ -71,26 +70,26 @@ stop(Handlers) ->
 tryStartAsyncMgr(undefined, _Window, _SinkS) ->
    ignore;
 tryStartAsyncMgr(Threshold, Window, Sink) ->
-   case
-   startThrottle(Sink, Threshold, Window)
-tryStartAsyncMgr(_Sink, Threshold, _Window) when not is_integer(Threshold) orelse Threshold < 0 ->
-   error_logger:error_msg("Invalid value for 'asyncThreshold': ~p~n", [Threshold]),
-   throw({error, bad_config});
-tryStartAsyncMgr(Sink, Threshold, undefined) ->
-   startThrottle(Sink, Threshold, erlang:trunc(Threshold * 0.2));
-tryStartAsyncMgr(_Sink, Threshold, Window) when not is_integer(Window) orelse Window > Threshold orelse Window < 0 ->
-   error_logger:error_msg("Invalid value for 'asyncThresholdWindow': ~p~n", [Window]),
-   throw({error, bad_config});
-tryStartAsyncMgr(Sink, Threshold, Window) ->
-   startThrottle(Sink, Threshold, Window).
+   case Window of
+      undefined ->
+         _ = supervisor:start_child(rumHWatcherSup, [Sink, ?RumBackendThrottle, [Threshold, erlang:trunc(Threshold * 0.2)]]);
+      _ ->
+         _ = supervisor:start_child(rumHWatcherSup, [Sink, ?RumBackendThrottle, [Threshold, Window]])
+   end,
+   ok.
 
-startThrottle(Sink, Threshold, Window) ->
-   _ = supervisor:start_child(rumHWatcherSup, [Sink, ?RumBackendThrottle, [Threshold, Window]]),
+tryInstallKiller(undefined, _ReTime, _Sink) -> ok;
+tryInstallKiller(HWM, ReTime, Sink) ->
+   case ReTime of
+      undefined ->
+         _ = supervisor:start_child(rumHWatcherSup, [Sink, rumMgrKiller, [HWM, 5000]]);
+      _ ->
+         _ = supervisor:start_child(rumHWatcherSup, [Sink, rumMgrKiller, [HWM, ReTime]])
+   end,
    ok.
 
-start_handlers(_Sink, undefined) ->
-   ok;
-start_handlers(_Sink, Handlers) when not is_list(Handlers) ->
+start_handlers(undefined, _Sink) -> ok;
+start_handlers(Handlers, _Sink) when not is_list(Handlers) ->
    error_logger:error_msg("Invalid value for 'handlers' (must be list): ~p~n", [Handlers]),
    throw({error, bad_config});
 start_handlers(Sink, Handlers) ->
@@ -144,15 +143,6 @@ interpret_hwm(HWM) when not is_integer(HWM) orelse HWM < 0 ->
 interpret_hwm(HWM) ->
    HWM.
 
-maybe_install_sink_killer(_Sink, undefined, _ReinstallTimer) -> ok;
-maybe_install_sink_killer(Sink, HWM, undefined) -> maybe_install_sink_killer(Sink, HWM, 5000);
-maybe_install_sink_killer(Sink, HWM, ReinstallTimer) when is_integer(HWM) andalso is_integer(ReinstallTimer) andalso HWM >= 0 andalso ReinstallTimer >= 0 ->
-   _ = supervisor:start_child(lager_handler_watcher_sup, [Sink, lager_manager_killer,
-      [HWM, ReinstallTimer]]);
-maybe_install_sink_killer(_Sink, HWM, ReinstallTimer) ->
-   error_logger:error_msg("Invalid value for 'killer_hwm': ~p or 'killer_reinstall_after': ~p", [HWM, ReinstallTimer]),
-   throw({error, bad_config}).
-
 -spec start_error_logger_handler(boolean(), pos_integer(), list()) -> list().
 start_error_logger_handler(false, _HWM, _Whitelist) ->
    [];
@@ -218,8 +208,8 @@ configure_sink(Sink, SinkDef) ->
    ChildId = rumUtil:make_internal_sink_name(Sink),
    _ = supervisor:start_child(eRum_sup, {ChildId, {gen_event, start_link, [{local, Sink}]}, permanent, 5000, worker, dynamic}),
    tryStartAsyncMgr(Sink, proplists:get_value(asyncThreshold, SinkDef), proplists:get_value(asyncThresholdWindow, SinkDef)),
-   _ = maybe_install_sink_killer(Sink, proplists:get_value(killer_hwm, SinkDef),
-      proplists:get_value(killer_reinstall_after, SinkDef)),
+   _ = tryInstallKiller(Sink, proplists:get_value(killerHwm, SinkDef),
+      proplists:get_value(killerReTime, SinkDef)),
    start_handlers(Sink, proplists:get_value(handlers, SinkDef, [])),
    eRum:update_loglevel_config(Sink).
 

src/eRum_sup.erl

@@ -75,11 +75,11 @@ init(_Args) ->
 crashLogSpec(false) ->
    undefined;
 crashLogSpec(File) ->
-   MaxBytes = rumUtil:get_env(?RumAppName, crash_log_msg_size, 65536),
-   RotationSize = rumUtil:get_env(?RumAppName, crash_log_size, 0),
-   RotationCount = rumUtil:get_env(?RumAppName, crash_log_count, 0),
-   RotationDate = rumUtil:get_env(?RumAppName, crash_log_date, "$D0"),
-   RotationMod = rumUtil:get_env(?RumAppName, crash_log_rotator, lager_rotator_default),
+   MaxBytes = rumUtil:get_env(crash_log_msg_size, 65536),
+   RotationSize = rumUtil:get_env(crash_log_size, 0),
+   RotationCount = rumUtil:get_env(crash_log_count, 0),
+   RotationDate = rumUtil:get_env(crash_log_date, "$D0"),
+   RotationMod = rumUtil:get_env(crash_log_rotator, lager_rotator_default),
    #{
       id => rumCrashLog,
       start => {rumCrashLog, start_link, [File, MaxBytes, RotationSize, RotationDate, RotationCount, RotationMod]},

src/mgrKiller/rumMgrKiller.erl

@@ -9,30 +9,30 @@
 -include("eRum.hrl").
 
 -record(state, {
-   killer_hwm :: non_neg_integer(),
-   killer_reinstall_after :: non_neg_integer()
+   killerHwm :: non_neg_integer(),
+   killerReTime :: non_neg_integer()
 }).
 
 kill_me() ->
    gen_event:call(rumEvent, ?MODULE, kill_self).
 
 init([KillerHWM, KillerReinstallAfter]) ->
-   {ok, #state{killer_hwm = KillerHWM, killer_reinstall_after = KillerReinstallAfter}}.
+   {ok, #state{killerHwm = KillerHWM, killerReTime = KillerReinstallAfter}}.
 
 handle_call(get_loglevel, State) ->
    {ok, {mask, ?LOG_NONE}, State};
 handle_call({set_loglevel, _Level}, State) ->
    {ok, ok, State};
-handle_call(get_settings, State = #state{killer_hwm = KillerHWM, killer_reinstall_after = KillerReinstallAfter}) ->
+handle_call(get_settings, State = #state{killerHwm = KillerHWM, killerReTime = KillerReinstallAfter}) ->
    {ok, [KillerHWM, KillerReinstallAfter], State};
-handle_call(kill_self, #state{killer_hwm = KillerHWM, killer_reinstall_after = KillerReinstallAfter}) ->
+handle_call(kill_self, #state{killerHwm = KillerHWM, killerReTime = KillerReinstallAfter}) ->
    exit({kill_me, [KillerHWM, KillerReinstallAfter]});
 handle_call(_Request, State) ->
    {ok, ok, State}.
 %% It's not the best idea in the world to check the queue length for every
 %% log message.  We can make this operation work on a poll timer in the
 %% future.
-handle_event({log, _Message}, State = #state{killer_hwm = KillerHWM, killer_reinstall_after = KillerReinstallAfter}) ->
+handle_event({log, _Message}, State = #state{killerHwm = KillerHWM, killerReTime = KillerReinstallAfter}) ->
    {message_queue_len, Len} = process_info(self(), message_queue_len),
    case Len > KillerHWM of
       true ->

src/utils/rumUtil.erl

@@ -29,7 +29,7 @@
    , otp_version/0
    , maybe_flush/2
    , has_file_changed/3
-   , get_env/3
+   , get_env/2
 ]).
 
 -ifdef(TEST).
@@ -638,14 +638,9 @@ has_file_changed(Name, Inode0, Ctime0) ->
          {true, undefined}
    end.
 
--spec get_env(Application, Par, Def) -> Val when
-   Application :: atom(),
-   Par :: atom(),
-   Def :: term(),
-   Val :: term().
-
-get_env(Application, Key, Def) ->
-   case application:get_env(Application, Key) of
+-spec get_env(Par :: atom(), Def :: term()) -> Val :: term().
+get_env(Key, Def) ->
+   case application:get_env(?RumAppName, Key) of
       {ok, Val} ->
          Val;
       _ ->

src/watcher/rumHWatcherSrv.erl

@@ -78,7 +78,7 @@ handleInfo({reboot, Sink}, State) ->
 handleInfo(stop, State) ->
    {stop, normal, State};
 handleInfo({'EXIT', _Pid, killed}, #state{module = Module, config = Config, sink = Sink} = State) ->
-   Tmr = application:get_env(lager, killer_reinstall_after, 5000),
+   Tmr = application:get_env(lager, killerReTime, 5000),
    _ = timer:apply_after(Tmr, lager_app, start_handler, [Sink, Module, Config]),
    {stop, normal, State};
 handleInfo(_Info, State) ->
@@ -187,7 +187,7 @@ reinstall_handlers_after_killer_hwm_test_() ->
             application:load(lager),
             application:set_env(lager, handlers, [{lager_manager_killer, [1000, 5000]}]),
             application:set_env(lager, error_logger_redirect, false),
-            application:set_env(lager, killer_reinstall_after, 5000),
+            application:set_env(lager, killerReTime, 5000),
             application:unset_env(lager, crash_log),
             eRum:start(),
             eRum:trace_file("foo", [{foo, "bar"}], error),

test/lager_manager_killer_test.erl

@@ -20,8 +20,8 @@ overload_test_() ->
          application:set_env(lager, handlers, [{lager_slow_backend, [{delay, Delay}]}]),
          application:set_env(lager, asyncThreshold, undefined),
          application:set_env(lager, error_logger_redirect, true),
-         application:set_env(lager, killer_hwm, KillerHWM),
-         application:set_env(lager, killer_reinstall_after, KillerReinstallAfter),
+         application:set_env(lager, killerHwm, KillerHWM),
+         application:set_env(lager, killerReTime, KillerReinstallAfter),
          ensure_started(lager),
          rumConfig:set(async, true),
          Manager = whereis(rumEvent),
@@ -57,8 +57,8 @@ overload_alternate_sink_test_() ->
          application:set_env(lager, handlers, []),
          application:set_env(lager, extra_sinks, [{?TEST_SINK_EVENT, [
             {handlers, [{lager_slow_backend, [{delay, Delay}]}]},
-            {killer_hwm, KillerHWM},
-            {killer_reinstall_after, KillerReinstallAfter},
+            {killerHwm, KillerHWM},
+            {killerReTime, KillerReinstallAfter},
             {asyncThreshold, undefined}
          ]}]),
          application:set_env(lager, error_logger_redirect, true),