ft: 代码修改

src/backend/rumBkdConsole.erl

@@ -29,7 +29,7 @@
 -define(DefOpts, [{use_stderr, false}, {group_leader, false}, {id, ?MODULE}, {formatter, rumFormatter}, {formatter_config, ?DEFAULT_FORMAT_CONFIG}]).
 
 -record(state, {
-   level :: {'mask', integer()},
+   level :: integer(),
    out = user :: user | standard_error | pid(),
    id :: atom() | {atom(), any()},
    formatter :: atom(),
@@ -56,7 +56,7 @@ init(Opts) ->
          true = checkOpts(Opts),
          Colors = ?IIF(rumUtil:get_env(colored, false), rumUtil:get_env(colors, []), []),
          Level = rumUtil:get_opt(level, Opts, undefined),
-         LevelMask = rumUtil:config_to_mask(Level),
+         LevelMask = rumUtil:configToMask(Level),
          [UseErr, GroupLeader, Id, Formatter, Config] = [rumUtil:get_opt(Key, Opts, Def) || {Key, Def} <- ?DefOpts],
          Out = ?IIF(UseErr, standard_error, ?IIF(GroupLeader == false, user, begin erlang:monitor(process, GroupLeader), GroupLeader end)),
          {ok, #state{level = LevelMask, id = Id, out = Out, formatter = Formatter, formatConfig = Config, colors = Colors}}
@@ -83,19 +83,19 @@ checkOpts([H | _]) ->
 handleCall(mGetLogLevel, #state{level = Level} = State) ->
    {reply, Level, State};
 handleCall({mSetLogLevel, Level}, State) ->
-   try rumUtil:config_to_mask(Level) of
+   try rumUtil:configToMask(Level) of
       Levels ->
          {reply, ok, State#state{level = Levels}}
    catch
       _:_ ->
-         {reply, {error, bad_log_level}, State}
+         {reply, {error, bad_log_level}, State}clo
    end;
 handleCall(_Msg, State) ->
    ?ERR("~p call receive unexpect msg ~p ~n ", [?MODULE, _Msg]),
    {reply, ok, State}.
 
 handleEvent({mWriteLog, Message}, #state{level = Level, out = Out, formatter = Formatter, formatConfig = FormatConfig, colors = Colors, id = ID}) ->
-   case rumUtil:is_loggable(Message, Level, ID) of
+   case rumUtil:isLoggAble(Message, Level, ID) of
       true ->
          io:put_chars(Out, Formatter:format(Message, FormatConfig, Colors)),
          kpS;
@@ -195,7 +195,7 @@ console_log_test_() ->
                register(user, Pid),
                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)), []}),
+               rumConfig:set({rumEvent, loglevel}, {rumUtil:configToMask(info), []}),
                eRum:log(info, self(), "Test message"),
                receive
                   {io_request, From, ReplyAs, {put_chars, unicode, Msg}} ->
@@ -215,7 +215,7 @@ console_log_test_() ->
                register(user, Pid),
                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)), []}),
+               rumConfig:set({rumEvent, loglevel}, {rumUtil:configToMask(info), []}),
                eRum:info("Test message"),
                PidStr = pid_to_list(self()),
                receive
@@ -260,7 +260,7 @@ console_log_test_() ->
                register(user, Pid),
                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)), []}),
+               rumConfig:set({rumEvent, loglevel}, {rumUtil:configToMask(info), []}),
                eRum:debug("Test message"),
                receive
                   {io_request, From, ReplyAs, {put_chars, unicode, _Msg}} ->
@@ -289,7 +289,7 @@ console_log_test_() ->
                unregister(user),
                register(user, Pid),
                gen_event:add_handler(rumEvent, lager_console_backend, [{level, info}]),
-               rumConfig:set({rumEvent, loglevel}, {element(2, rumUtil:config_to_mask(info)), []}),
+               rumConfig:set({rumEvent, loglevel}, {rumUtil:configToMask(info), []}),
                erlang:group_leader(Pid, whereis(rumEvent)),
                eRum:debug("Test message"),
                receive
@@ -328,7 +328,7 @@ console_log_test_() ->
                unregister(user),
                register(user, Pid),
                gen_event:add_handler(rumEvent, lager_console_backend, [{level, info}]),
-               rumConfig:set({rumEvent, loglevel}, {element(2, rumUtil:config_to_mask(info)), []}),
+               rumConfig:set({rumEvent, loglevel}, {rumUtil:configToMask(info), []}),
                eRum:set_loglevel(lager_console_backend, '!=info'),
                erlang:group_leader(Pid, whereis(rumEvent)),
                eRum:debug("Test message"),
@@ -359,7 +359,7 @@ console_log_test_() ->
                unregister(user),
                register(user, Pid),
                gen_event:add_handler(rumEvent, lager_console_backend, [{level, info}]),
-               rumConfig:set({rumEvent, loglevel}, {element(2, rumUtil:config_to_mask(info)), []}),
+               rumConfig:set({rumEvent, loglevel}, {rumUtil:configToMask(info), []}),
                eRum:set_loglevel(lager_console_backend, '=debug'),
                erlang:group_leader(Pid, whereis(rumEvent)),
                eRum:debug("Test message"),
@@ -388,7 +388,7 @@ console_log_test_() ->
             fun() ->
                Pid = spawn(F(self())),
                gen_event:add_handler(rumEvent, lager_console_backend, [{level, info}, {group_leader, Pid}]),
-               rumConfig:set({rumEvent, loglevel}, {element(2, rumUtil:config_to_mask(info)), []}),
+               rumConfig:set({rumEvent, loglevel}, {rumUtil:configToMask(info), []}),
                eRum:info("Test message"),
                ?assertNotEqual({group_leader, Pid}, erlang:process_info(whereis(rumEvent), group_leader)),
                receive

src/backend/rumBkdFile.erl

@@ -19,7 +19,7 @@
 -compile([{parse_transform, lager_transform}]).
 -endif.
 
--export([config_to_id/1]).
+-export([configToId/1]).
 
 -export([
    init/1
@@ -32,7 +32,7 @@
 
 -record(state, {
    fileName :: string(),
-   level :: {'mask', integer()},
+   level :: integer(),
    fd :: file:io_device() | undefined,
    inode :: integer() | undefined,
    ctime :: file:date_time() | undefined,
@@ -44,7 +44,7 @@
    shaper :: rumShaper(),
    formatter :: atom(),
    formatterConfig :: any(),
-   sync_on :: {'mask', integer()},
+   sync_on :: integer(),
    checkInterval = ?RumDefCheckInterval :: non_neg_integer(),
    syncInterval = ?RumDefSyncInterval :: non_neg_integer(),
    sync_size = ?RumDefSyncSize :: non_neg_integer(),
@@ -89,12 +89,12 @@ init(Opts) ->
    FormatterConfig = rumUtil:get_opt(formatter_config, Opts, ?RumDefFormatterCfg),
 
    %% 需要二次转换的配置在这里处理
-   Level = validate_loglevel(CfgLevel),
-   SyncOn = validate_loglevel(CfgSyncOn),
+   Level = validateLogLevel(CfgLevel),
+   SyncOn = validateLogLevel(CfgSyncOn),
    CheckInterval = ?IIF(CfgCheckInterval == always, 0, CfgCheckInterval),
    {ok, Date} = rumUtil:parseRotateSpec(CfgDate),
-
    FileName = rumUtil:parsePath(RelName),
+
    scheduleRotation(Date, FileName),
    Shaper = rumUtil:maybe_flush(Flush, #rumShaper{hwm = HighWaterMark, flushThreshold = FlushThr, id = FileName}),
    TemState = #state{
@@ -115,7 +115,7 @@ init(Opts) ->
 handleCall(mGetLogLevel, #state{level = Level} = State) ->
    {reply, Level, State};
 handleCall({mSetLogLevel, Level}, #state{fileName = Ident} = State) ->
-   case validate_loglevel(Level) of
+   case validateLogLevel(Level) of
       false ->
          {reply, {error, bad_loglevel}, State};
       Levels ->
@@ -139,8 +139,8 @@ handleCall(_Msg, State) ->
    ?ERR("~p call receive unexpect msg ~p ~n ", [?MODULE, _Msg]),
    {reply, ok, State}.
 
-handleEvent({mWriteLog, Message}, #state{fileName = FileName, level = L, shaper = Shaper, formatter = Formatter, formatterConfig = FormatConfig} = State) ->
-   case rumUtil:is_loggable(Message, L, {rumBkdFile, FileName}) of
+handleEvent({mWriteLog, Message}, #state{fileName = FileName, level = Level, shaper = Shaper, formatter = Formatter, formatterConfig = FormatConfig} = State) ->
+   case rumUtil:isLoggAble(Message, Level, {rumBkdFile, FileName}) of
       true ->
          case rumUtil:check_hwm(Shaper) of
             {true, Drop, #rumShaper{hwm = Hwm} = NewShaper} ->
@@ -167,11 +167,11 @@ handleEvent(_Msg, _State) ->
    kpS.
 
 handleInfo({mRotate, File}, #state{fileName = File, count = Count, date = Date, rotator = Rotator} = State0) ->
-   State1 = close_file(State0),
+   State1 = closeFile(State0),
    _ = Rotator:rotateLogfile(File, Count),
    scheduleRotation(File, Date),
    {ok, State1};
-handleInfo({shaper_expired, Name}, #state{shaper = Shaper, fileName = Name, formatter = Formatter, formatterConfig = FormatConfig} = State) ->
+handleInfo({mShaperExpired, Name}, #state{shaper = Shaper, fileName = Name, formatter = Formatter, formatterConfig = FormatConfig} = State) ->
    _ = case Shaper#rumShaper.dropped of
           0 ->
              ok;
@@ -189,29 +189,12 @@ handleInfo(_Info, State) ->
 
 terminate(_Reason, State) ->
    %% leaving this function call unmatched makes dialyzer cranky
-   _ = close_file(State),
+   _ = closeFile(State),
    ok.
 
 code_change(_OldVsn, State, _Extra) ->
    {ok, State}.
 
-%% Convert the config into a gen_event handler ID
-config_to_id({Name, _Severity}) when is_list(Name) ->
-   {?MODULE, Name};
-config_to_id({Name, _Severity, _Size, _Rotation, _Count}) ->
-   {?MODULE, Name};
-config_to_id([{Name, _Severity, _Size, _Rotation, _Count}, _Format]) ->
-   {?MODULE, Name};
-config_to_id([{Name, _Severity}, _Format]) when is_list(Name) ->
-   {?MODULE, Name};
-config_to_id(Config) ->
-   case proplists:get_value(file, Config) of
-      undefined ->
-         erlang:error(no_file);
-      File ->
-         {?MODULE, File}
-   end.
-
 write(#state{fileName = Name, fd = FD,
    inode = Inode, ctime = Ctime,
    flap = Flap, size = RotSize,
@@ -222,7 +205,7 @@ write(#state{fileName = Name, fd = FD,
          Buffer = {State0#state.sync_size, State0#state.syncInterval},
          case Rotator:ensureLogfile(Name, FD, Inode, Ctime, Buffer) of
             {ok, {_FD, _Inode, _Ctime, Size}} when RotSize > 0, Size > RotSize ->
-               State1 = close_file(State0),
+               State1 = closeFile(State0),
                case Rotator:rotateLogfile(Name, Count) of
                   ok ->
                      %% go around the loop again, we'll do another rotation check and hit the next clause of ensureLogfile
@@ -271,7 +254,7 @@ write_should_check(#state{lastCheck = LastCheck0, checkInterval = CheckInterval,
 do_write(#state{fd = FD, fileName = Name, flap = Flap} = State, Level, Msg) ->
    %% delayed_write doesn't report errors
    _ = file:write(FD, unicode:characters_to_binary(Msg)),
-   {mask, SyncLevel} = State#state.sync_on,
+   SyncLevel = State#state.sync_on,
    case (Level band SyncLevel) =/= 0 of
       true ->
          %% force a sync on any message that matches the 'sync_on' bitmask
@@ -290,8 +273,25 @@ do_write(#state{fd = FD, fileName = Name, flap = Flap} = State, Level, Msg) ->
          State
    end.
 
-validate_loglevel(Level) ->
-   try rumUtil:config_to_mask(Level) of
+%% Convert the config into a gen_event handler ID
+configToId({Name, _Severity}) when is_list(Name) ->
+   {?MODULE, Name};
+configToId({Name, _Severity, _Size, _Rotation, _Count}) ->
+   {?MODULE, Name};
+configToId([{Name, _Severity, _Size, _Rotation, _Count}, _Format]) ->
+   {?MODULE, Name};
+configToId([{Name, _Severity}, _Format]) when is_list(Name) ->
+   {?MODULE, Name};
+configToId(Config) ->
+   case proplists:get_value(file, Config) of
+      undefined ->
+         erlang:error(no_file);
+      File ->
+         {?MODULE, File}
+   end.
+
+validateLogLevel(Level) ->
+   try rumUtil:configToMask(Level) of
       Levels ->
          Levels
    catch
@@ -304,7 +304,7 @@ checkOpts([], IsFile) ->
 checkOpts([{file, _File} | Tail], _IsFile) ->
    checkOpts(Tail, true);
 checkOpts([{level, Level} | Tail], IsFile) ->
-   ?IIF(validate_loglevel(Level), checkOpts(Tail, IsFile), ({error, {invalid_log_level, Level}}));
+   ?IIF(validateLogLevel(Level), checkOpts(Tail, IsFile), ({error, {invalid_log_level, Level}}));
 checkOpts([{size, Size} | Tail], IsFile) when is_integer(Size), Size >= 0 ->
    checkOpts(Tail, IsFile);
 checkOpts([{count, Count} | Tail], IsFile) when is_integer(Count), Count >= 0 ->
@@ -340,30 +340,32 @@ scheduleRotation(Date, Name) ->
    erlang:send_after(rumUtil:calcNextRotateMs(Date), self(), {mRotate, Name}),
    ok.
 
-close_file(#state{fd = undefined} = State) ->
-   State;
-close_file(#state{fd = FD} = State) ->
-   %% Flush and close any file handles.
-   %% delayed write can cause file:close not to do a close
-   _ = file:datasync(FD),
-   _ = file:close(FD),
-   _ = file:close(FD),
-   State#state{fd = undefined}.
+closeFile(#state{fd = Fd} = State) ->
+   case Fd of
+      undefined -> State;
+      _ ->
+         %% Flush and close any file handles.
+         %% delayed write can cause file:close not to do a close
+         _ = file:datasync(Fd),
+         _ = file:close(Fd),
+         _ = file:close(Fd),
+         State#state{fd = undefined}
+   end.
 
 -ifdef(TEST).
 
 get_loglevel_test() ->
    {ok, Level, _} = handleCall(mGetLogLevel,
-      #state{fileName = "bar", level = rumUtil:config_to_mask(info), fd = 0, inode = 0, ctime = undefined}),
-   ?assertEqual(Level, rumUtil:config_to_mask(info)),
+      #state{fileName = "bar", level = rumUtil:configToMask(info), fd = 0, inode = 0, ctime = undefined}),
+   ?assertEqual(Level, rumUtil:configToMask(info)),
    {ok, Level2, _} = handleCall(mGetLogLevel,
-      #state{fileName = "foo", level = rumUtil:config_to_mask(warning), fd = 0, inode = 0, ctime = undefined}),
-   ?assertEqual(Level2, rumUtil:config_to_mask(warning)).
+      #state{fileName = "foo", level = rumUtil:configToMask(warning), fd = 0, inode = 0, ctime = undefined}),
+   ?assertEqual(Level2, rumUtil:configToMask(warning)).
 
 rotation_test_() ->
    {foreach,
       fun() ->
-         SyncLevel = validate_loglevel(?RumDefSyncLevel),
+         SyncLevel = validateLogLevel(?RumDefSyncLevel),
          SyncSize = ?RumDefSyncSize,
          SyncInterval = ?RumDefSyncInterval,
          Rotator = ?RumDefRotateMod,

src/backend/rumBkdThrottle.erl

@@ -31,7 +31,7 @@ init([{sink, Sink}, Hwm, Window]) ->
    {ok, #state{sink = Sink, hwm = Hwm, window_min = Hwm - Window}}.
 
 handle_call(mGetLogLevel, State) ->
-   {ok, {mask, ?LOG_NONE}, State};
+   {ok, ?LOG_NONE, State};
 handle_call({mSetLogLevel, _Level}, State) ->
    {ok, ok, State};
 handle_call(_Request, State) ->

src/eRum.erl

@@ -46,7 +46,7 @@
    , set_loglevel/2
    , set_loglevel/3
    , set_loglevel/4
-   , get_loglevels/1
+   , getLogLevels/1
    , updateLogevelCfg/1
    , posix_error/1
    , set_loghwm/2
@@ -422,15 +422,12 @@ status() ->
          Handlers)],
       "Active Traces:\n",
       [begin
-          LevelName = case Level of
-                         {mask, Mask} ->
+          LevelName =
                             case rumUtil:maskToLevels(Mask) of
                                [] -> none;
                                Levels -> hd(Levels)
-                            end;
-                         Num ->
-                            rumUtil:numToLevel(Num)
-                      end,
+                            end,
+
           io_lib:format("Tracing messages matching ~p (sink ~s) at level ~p to ~p\n",
              [Filter, Sink, LevelName, Destination])
        end || {Sink, {Filter, Level, Destination}} <- Traces],
@@ -491,13 +488,11 @@ get_loglevel(Handler) ->
 %% has multiple identifiers, the lowest is returned.
 get_loglevel(Sink, Handler) ->
    case gen_event:call(Sink, Handler, mGetLogLevel, infinity) of
-      {mask, Mask} ->
+      Mask when is_integer(Mask) ->
          case rumUtil:maskToLevels(Mask) of
             [] -> none;
             Levels -> hd(Levels)
          end;
-      X when is_integer(X) ->
-         rumUtil:numToLevel(X);
       Y -> Y
    end.
 
@@ -511,10 +506,8 @@ posix_error(Error) when is_atom(Error) ->
 posix_error(Error) ->
    safe_format_chop("~p", [Error], ?RumDefTruncation).
 
-%% @private
-get_loglevels(Sink) ->
-   [gen_event:call(Sink, Handler, mGetLogLevel, infinity) ||
-      Handler <- gen_event:which_handlers(Sink)].
+getLogLevels(Sink) ->
+   [gen_event:call(Sink, Handler, mGetLogLevel, infinity) || Handler <- gen_event:which_handlers(Sink)].
 
 %% @doc Set the loghwm for the default sink.
 set_loghwm(Handler, Hwm) when is_integer(Hwm) ->
@@ -547,19 +540,14 @@ updateLogevelCfg(error_logger) ->
    true;
 updateLogevelCfg(Sink) ->
    {_, Traces} = rumConfig:get({Sink, loglevel}, {ignore_me, []}),
-   MinLog = minimum_loglevel(get_loglevels(Sink)),
+   MinLog = minLogLevel(getLogLevels(Sink)),
    rumConfig:set({Sink, loglevel}, {MinLog, Traces}).
 
-%% @private
-minimum_loglevel(Levels) ->
-   lists:foldl(fun({mask, Mask}, Acc) ->
-      Mask bor Acc;
-      (Level, Acc) when is_integer(Level) ->
-         {mask, Mask} = rumUtil:config_to_mask(rumUtil:numToLevel(Level)),
-         Mask bor Acc;
-      (_, Acc) ->
-         Acc
-               end, 0, Levels).
+minLogLevel(Levels) ->
+   lists:foldl(
+      fun(Mask, Acc) ->
+         Mask bor Acc
+      end, 0, Levels).
 
 %% @doc Print the format string `Fmt' with `Args' safely with a size
 %% limit of `Limit'. If the format string is invalid, or not enough

src/eRum_app.erl

@@ -187,7 +187,7 @@ parseHandlers([{lager_file_backend, [{Key, _Value} | _] = Config} | T]) when is_
    [maybe_make_handler_id(lager_file_backend, Config) | parseHandlers(T)];
 parseHandlers([{lager_file_backend, Configs} | T]) ->
    ?INT_LOG(notice, "Deprecated lager_file_backend config detected, please consider updating it", []),
-   [{rumBkdFile:config_to_id(Config), Config} || Config <- Configs] ++
+   [{rumBkdFile:configToId(Config), Config} || Config <- Configs] ++
    parseHandlers(T);
 parseHandlers([{Mod, Config} | T]) when is_atom(Mod) ->
    [maybe_make_handler_id(Mod, Config) | parseHandlers(T)];
@@ -205,7 +205,7 @@ maybe_make_handler_id(Mod, Config) ->
    %%已经加载，这在启动阶段是不太可能的。使用代码:负载
    %%会在生成代码覆盖率报告时产生不良的副作用。
 
-   try Mod:config_to_id(Config) of
+   try Mod:configToId(Config) of
       Id ->
          {Id, Config}
    catch

src/errLogger/rumErrLoggerH.erl

@@ -108,7 +108,7 @@ handle_event(Event, #state{sink = Sink, shaper = Shaper} = State) ->
          {ok, State#state{shaper = NewShaper#rumShaper{dropped = D + 1}}}
    end.
 
-handle_info({shaper_expired, ?MODULE}, #state{sink = Sink, shaper = Shaper} = State) ->
+handle_info({mShaperExpired, ?MODULE}, #state{sink = Sink, shaper = Shaper} = State) ->
    case Shaper#rumShaper.dropped of
       0 ->
          ok;

src/mgrKiller/rumMgrKiller.erl

@@ -20,7 +20,7 @@ init([KillerHWM, KillerReinstallAfter]) ->
    {ok, #state{killerHwm = KillerHWM, killerReTime = KillerReinstallAfter}}.
 
 handle_call(mGetLogLevel, State) ->
-   {ok, {mask, ?LOG_NONE}, State};
+   {ok, ?LOG_NONE, State};
 handle_call({mSetLogLevel, _Level}, State) ->
    {ok, ok, State};
 handle_call(get_settings, State = #state{killerHwm = KillerHWM, killerReTime = KillerReinstallAfter}) ->

src/test/lager_common_test_backend.erl

@@ -14,7 +14,8 @@
    bounce/1]).
 
 %% holds the log messages for retreival on terminate
--record(state, {level :: {mask, integer()},
+-record(state, {
+   level :: integer(),
    formatter :: atom(),
    format_config :: any(),
    mWriteLog = [] :: list()}).
@@ -61,7 +62,7 @@ init([Level, false]) -> % for backwards compatibility
 init([Level, {Formatter, FormatterConfig}]) when is_atom(Formatter) ->
    case lists:member(Level, ?RumLevels) of
       true ->
-         {ok, #state{level = rumUtil:config_to_mask(Level),
+         {ok, #state{level = rumUtil:configToMask(Level),
             formatter = Formatter,
             format_config = FormatterConfig}};
       _ ->
@@ -74,7 +75,7 @@ init(Level) ->
 %% @private
 handle_event({mWriteLog, Message},
    #state{level = L, formatter = Formatter, format_config = FormatConfig, mWriteLog = Logs} = State) ->
-   case rumUtil:is_loggable(Message, L, ?MODULE) of
+   case rumUtil:isLoggAble(Message, L, ?MODULE) of
       true ->
          Log = Formatter:format(Message, FormatConfig),
          ct:pal(Log),
@@ -94,7 +95,7 @@ handle_call(mGetLogLevel, #state{level = Level} = State) ->
 handle_call({mSetLogLevel, Level}, State) ->
    case lists:member(Level, ?RumLevels) of
       true ->
-         {ok, ok, State#state{level = rumUtil:config_to_mask(Level)}};
+         {ok, ok, State#state{level = rumUtil:configToMask(Level)}};
       _ ->
          {ok, {error, bad_log_level}, State}
    end;

src/utils/rumConfig.erl

@@ -28,7 +28,7 @@ init() ->
 
 initSink(Sink) ->
    %% use insert_new here so that if we're in an appup we don't mess anything up until lager is completely started, allow all messages to go through
-   insert_new({Sink, loglevel}, {element(2, rumUtil:config_to_mask(debug)), []}).
+   insert_new({Sink, loglevel}, {rumUtil:configToMask(debug), []}).
 
 global_get(Key) ->
    global_get(Key, undefined).

src/utils/rumUtil.erl

@@ -8,7 +8,7 @@
    , levelToNum/1
    , levelToChr/1
    , numToLevel/1
-   , config_to_mask/1
+   , configToMask/1
    , atomCfgToLevels/1
    , maskToLevels/1
    , nowMs/0
@@ -20,7 +20,7 @@
    , calcNextRotateDt/2
    , validate_trace/1
    , check_traces/4
-   , is_loggable/3
+   , isLoggAble/3
    , trace_filter/1
    , trace_filter/2
    , parsePath/1
@@ -81,8 +81,8 @@ levelToChr(alert) -> $A;
 levelToChr(emergency) -> $M;
 levelToChr(none) -> $ .
 
--spec config_to_mask(atom()|string()) -> {'mask', integer()}.
-config_to_mask(Conf) ->
+-spec configToMask(atom()|string()) -> integer().
+configToMask(Conf) ->
    Levels = atomCfgToLevels(Conf),
    levelsToMask(Levels, 0).
 
@@ -385,7 +385,7 @@ validate_trace({Filter, Level, {Destination, ID}}) when is_tuple(Filter); is_lis
    end;
 validate_trace({Filter, Level, Destination}) when is_tuple(Filter); is_list(Filter), is_atom(Level), is_atom(Destination) ->
    ValidFilter = validate_trace_filter(Filter),
-   try config_to_mask(Level) of
+   try configToMask(Level) of
       _ when not ValidFilter ->
          {error, invalid_trace};
       L when is_list(Filter) ->
@@ -454,7 +454,7 @@ trace_acc([{Key, '<', Val} | T], Acc) ->
 
 check_traces(_, _, [], Acc) ->
    lists:flatten(Acc);
-check_traces(Attrs, Level, [{_, {mask, FilterLevel}, _} | Flows], Acc) when (Level band FilterLevel) == 0 ->
+check_traces(Attrs, Level, [{_, FilterLevel, _} | Flows], Acc) when (Level band FilterLevel) == 0 ->
    check_traces(Attrs, Level, Flows, Acc);
 check_traces(Attrs, Level, [{Filter, _, _} | Flows], Acc) when length(Attrs) < length(Filter) ->
    check_traces(Attrs, Level, Flows, Acc);
@@ -475,18 +475,9 @@ check_trace(Attrs, {Filter, _Level, Dest}) when is_tuple(Filter) ->
          []
    end.
 
--spec is_loggable(rumMsg:rumMsg(), non_neg_integer()|{'mask', non_neg_integer()}, term()) -> boolean().
-is_loggable(Msg, {mask, Mask}, MyName) ->
-   %% using syslog style comparison flags
-   %S = lager_msg:severity_as_int(Msg),
-   %?debugFmt("comparing masks ~.2B and ~.2B -> ~p~n", [S, Mask, S band Mask]),
-   (rumMsg:severity_as_int(Msg) band Mask) /= 0 orelse
-      lists:member(MyName, rumMsg:destinations(Msg));
-is_loggable(Msg, SeverityThreshold, MyName) when is_atom(SeverityThreshold) ->
-   is_loggable(Msg, levelToNum(SeverityThreshold), MyName);
-is_loggable(Msg, SeverityThreshold, MyName) when is_integer(SeverityThreshold) ->
-   rumMsg:severity_as_int(Msg) =< SeverityThreshold orelse
-      lists:member(MyName, rumMsg:destinations(Msg)).
+-spec isLoggAble(rumMsg:rumMsg(), non_neg_integer(), term()) -> boolean().
+isLoggAble(Msg, Mask, MyName) ->
+   (rumMsg:severity_as_int(Msg) band Mask) /= 0 orelse lists:member(MyName, rumMsg:destinations(Msg)).
 
 parsePath(RelPath) ->
    NewRelPath =
@@ -559,7 +550,7 @@ check_hwm(Shaper = #rumShaper{lastTime = Last, dropped = Drop}) ->
                     end,
          Timer = case erlang:read_timer(Shaper#rumShaper.timer) of
                     false ->
-                       erlang:send_after(trunc((1000000 - N) / 1000), self(), {shaper_expired, Shaper#rumShaper.id});
+                       erlang:send_after(trunc((1000000 - N) / 1000), self(), {mShaperExpired, Shaper#rumShaper.id});
                     _ ->
                        Shaper#rumShaper.timer
                  end,
@@ -735,42 +726,42 @@ check_trace_test() ->
    trace_filter(none),
    %% match by module
    ?assertEqual([foo], check_traces([{module, ?MODULE}], ?EMERGENCY, [
-      {[{module, ?MODULE}], config_to_mask(emergency), foo},
-      {[{module, test}], config_to_mask(emergency), bar}], [])),
+      {[{module, ?MODULE}], configToMask(emergency), foo},
+      {[{module, test}], configToMask(emergency), bar}], [])),
    %% match by module, but other unsatisfyable attribute
    ?assertEqual([], check_traces([{module, ?MODULE}], ?EMERGENCY, [
-      {[{module, ?MODULE}, {foo, bar}], config_to_mask(emergency), foo},
-      {[{module, test}], config_to_mask(emergency), bar}], [])),
+      {[{module, ?MODULE}, {foo, bar}], configToMask(emergency), foo},
+      {[{module, test}], configToMask(emergency), bar}], [])),
    %% match by wildcard module
    ?assertEqual([bar], check_traces([{module, ?MODULE}], ?EMERGENCY, [
-      {[{module, ?MODULE}, {foo, bar}], config_to_mask(emergency), foo},
-      {[{module, '*'}], config_to_mask(emergency), bar}], [])),
+      {[{module, ?MODULE}, {foo, bar}], configToMask(emergency), foo},
+      {[{module, '*'}], configToMask(emergency), bar}], [])),
    %% wildcard module, one trace with unsatisfyable attribute
    ?assertEqual([bar], check_traces([{module, ?MODULE}], ?EMERGENCY, [
-      {[{module, '*'}, {foo, bar}], config_to_mask(emergency), foo},
-      {[{module, '*'}], config_to_mask(emergency), bar}], [])),
+      {[{module, '*'}, {foo, bar}], configToMask(emergency), foo},
+      {[{module, '*'}], configToMask(emergency), bar}], [])),
    %% wildcard but not present custom trace attribute
    ?assertEqual([bar], check_traces([{module, ?MODULE}], ?EMERGENCY, [
-      {[{module, '*'}, {foo, '*'}], config_to_mask(emergency), foo},
-      {[{module, '*'}], config_to_mask(emergency), bar}], [])),
+      {[{module, '*'}, {foo, '*'}], configToMask(emergency), foo},
+      {[{module, '*'}], configToMask(emergency), bar}], [])),
    %% wildcarding a custom attribute works when it is present
    ?assertEqual([bar, foo], check_traces([{module, ?MODULE}, {foo, bar}], ?EMERGENCY, [
-      {[{module, '*'}, {foo, '*'}], config_to_mask(emergency), foo},
-      {[{module, '*'}], config_to_mask(emergency), bar}], [])),
+      {[{module, '*'}, {foo, '*'}], configToMask(emergency), foo},
+      {[{module, '*'}], configToMask(emergency), bar}], [])),
    %% denied by level
    ?assertEqual([], check_traces([{module, ?MODULE}, {foo, bar}], ?INFO, [
-      {[{module, '*'}, {foo, '*'}], config_to_mask(emergency), foo},
-      {[{module, '*'}], config_to_mask(emergency), bar}], [])),
+      {[{module, '*'}, {foo, '*'}], configToMask(emergency), foo},
+      {[{module, '*'}], configToMask(emergency), bar}], [])),
    %% allowed by level
    ?assertEqual([foo], check_traces([{module, ?MODULE}, {foo, bar}], ?INFO, [
-      {[{module, '*'}, {foo, '*'}], config_to_mask(debug), foo},
-      {[{module, '*'}], config_to_mask(emergency), bar}], [])),
+      {[{module, '*'}, {foo, '*'}], configToMask(debug), foo},
+      {[{module, '*'}], configToMask(emergency), bar}], [])),
    ?assertEqual([anythingbutnotice, infoandbelow, infoonly], check_traces([{module, ?MODULE}], ?INFO, [
-      {[{module, '*'}], config_to_mask('=debug'), debugonly},
-      {[{module, '*'}], config_to_mask('=info'), infoonly},
-      {[{module, '*'}], config_to_mask('<=info'), infoandbelow},
-      {[{module, '*'}], config_to_mask('!=info'), anythingbutinfo},
-      {[{module, '*'}], config_to_mask('!=notice'), anythingbutnotice}
+      {[{module, '*'}], configToMask('=debug'), debugonly},
+      {[{module, '*'}], configToMask('=info'), infoonly},
+      {[{module, '*'}], configToMask('<=info'), infoandbelow},
+      {[{module, '*'}], configToMask('!=info'), anythingbutinfo},
+      {[{module, '*'}], configToMask('!=notice'), anythingbutnotice}
    ], [])),
    application:stop(lager),
    application:stop(goldrush),
@@ -778,11 +769,11 @@ check_trace_test() ->
 
 is_loggable_test_() ->
    [
-      {"Loggable by severity only", ?_assert(is_loggable(rumMsg:new("", alert, [], []), 2, me))},
-      {"Not loggable by severity only", ?_assertNot(is_loggable(rumMsg:new("", critical, [], []), 1, me))},
-      {"Loggable by severity with destination", ?_assert(is_loggable(rumMsg:new("", alert, [], [you]), 2, me))},
-      {"Not loggable by severity with destination", ?_assertNot(is_loggable(rumMsg:new("", critical, [], [you]), 1, me))},
-      {"Loggable by destination overriding severity", ?_assert(is_loggable(rumMsg:new("", critical, [], [me]), 1, me))}
+      {"Loggable by severity only", ?_assert(isLoggAble(rumMsg:new("", alert, [], []), 2, me))},
+      {"Not loggable by severity only", ?_assertNot(isLoggAble(rumMsg:new("", critical, [], []), 1, me))},
+      {"Loggable by severity with destination", ?_assert(isLoggAble(rumMsg:new("", alert, [], [you]), 2, me))},
+      {"Not loggable by severity with destination", ?_assertNot(isLoggAble(rumMsg:new("", critical, [], [you]), 1, me))},
+      {"Loggable by destination overriding severity", ?_assert(isLoggAble(rumMsg:new("", critical, [], [me]), 1, me))}
    ].
 
 format_time_test_() ->
@@ -816,7 +807,7 @@ format_time_test_() ->
 
 config_to_levels_test() ->
    ?assertEqual([none], atomCfgToLevels('none')),
-   ?assertEqual({mask, 0}, config_to_mask('none')),
+   ?assertEqual(0, configToMask('none')),
    ?assertEqual([debug], atomCfgToLevels('=debug')),
    ?assertEqual([debug], atomCfgToLevels('<info')),
    ?assertEqual(levels() -- [debug], atomCfgToLevels('!=debug')),
@@ -837,10 +828,10 @@ config_to_levels_test() ->
    ok.
 
 config_to_mask_test() ->
-   ?assertEqual({mask, 0}, config_to_mask('none')),
-   ?assertEqual({mask, ?DEBUG bor ?INFO bor ?NOTICE bor ?WARNING bor ?ERROR bor ?CRITICAL bor ?ALERT bor ?EMERGENCY}, config_to_mask('debug')),
-   ?assertEqual({mask, ?WARNING bor ?ERROR bor ?CRITICAL bor ?ALERT bor ?EMERGENCY}, config_to_mask('warning')),
-   ?assertEqual({mask, ?DEBUG bor ?NOTICE bor ?WARNING bor ?ERROR bor ?CRITICAL bor ?ALERT bor ?EMERGENCY}, config_to_mask('!=info')),
+   ?assertEqual(0, configToMask('none')),
+   ?assertEqual(?DEBUG bor ?INFO bor ?NOTICE bor ?WARNING bor ?ERROR bor ?CRITICAL bor ?ALERT bor ?EMERGENCY, configToMask('debug')),
+   ?assertEqual(?WARNING bor ?ERROR bor ?CRITICAL bor ?ALERT bor ?EMERGENCY, configToMask('warning')),
+   ?assertEqual(?DEBUG bor ?NOTICE bor ?WARNING bor ?ERROR bor ?CRITICAL bor ?ALERT bor ?EMERGENCY, configToMask('!=info')),
    ok.
 
 mask_to_levels_test() ->

test/lager_slow_backend.erl

@@ -14,7 +14,7 @@ init([{delay, Delay}]) ->
    {ok, #state{delay = Delay}}.
 
 handle_call(mGetLogLevel, State) ->
-   {ok, rumUtil:config_to_mask(debug), State};
+   {ok, rumUtil:configToMask(debug), State};
 handle_call(_Request, State) ->
    {ok, ok, State}.