From 23026fefd21483b483afc31f92a7390b8c8dac5b Mon Sep 17 00:00:00 2001 From: SisMaker <1713699517@qq.com> Date: Sun, 14 Mar 2021 17:27:12 +0800 Subject: [PATCH] =?UTF-8?q?ft:=20=E4=BB=A3=E7=A0=81=E4=BF=AE=E6=94=B9?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/backend/rumBkdConsole.erl | 24 +++---- src/backend/rumBkdFile.erl | 98 +++++++++++++------------- src/backend/rumBkdThrottle.erl | 2 +- src/eRum.erl | 38 ++++------ src/eRum_app.erl | 4 +- src/errLogger/rumErrLoggerH.erl | 2 +- src/mgrKiller/rumMgrKiller.erl | 2 +- src/test/lager_common_test_backend.erl | 9 +-- src/utils/rumConfig.erl | 2 +- src/utils/rumUtil.erl | 91 +++++++++++------------- test/lager_slow_backend.erl | 2 +- 11 files changed, 128 insertions(+), 146 deletions(-) diff --git a/src/backend/rumBkdConsole.erl b/src/backend/rumBkdConsole.erl index 8cf9044..a1924ee 100644 --- a/src/backend/rumBkdConsole.erl +++ b/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 diff --git a/src/backend/rumBkdFile.erl b/src/backend/rumBkdFile.erl index 7b0bfaa..19d98cf 100644 --- a/src/backend/rumBkdFile.erl +++ b/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, diff --git a/src/backend/rumBkdThrottle.erl b/src/backend/rumBkdThrottle.erl index db1a728..3a61912 100644 --- a/src/backend/rumBkdThrottle.erl +++ b/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) -> diff --git a/src/eRum.erl b/src/eRum.erl index 57c47f7..d29ffb4 100644 --- a/src/eRum.erl +++ b/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 diff --git a/src/eRum_app.erl b/src/eRum_app.erl index 43af95f..eec75bf 100644 --- a/src/eRum_app.erl +++ b/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 diff --git a/src/errLogger/rumErrLoggerH.erl b/src/errLogger/rumErrLoggerH.erl index 3d26f12..040a7d3 100644 --- a/src/errLogger/rumErrLoggerH.erl +++ b/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; diff --git a/src/mgrKiller/rumMgrKiller.erl b/src/mgrKiller/rumMgrKiller.erl index b7d0acc..1e53981 100644 --- a/src/mgrKiller/rumMgrKiller.erl +++ b/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}) -> diff --git a/src/test/lager_common_test_backend.erl b/src/test/lager_common_test_backend.erl index 9afef64..6225c84 100644 --- a/src/test/lager_common_test_backend.erl +++ b/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; diff --git a/src/utils/rumConfig.erl b/src/utils/rumConfig.erl index be84fa7..6700599 100644 --- a/src/utils/rumConfig.erl +++ b/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). diff --git a/src/utils/rumUtil.erl b/src/utils/rumUtil.erl index 235cc36..ca85ce8 100644 --- a/src/utils/rumUtil.erl +++ b/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(' 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() -> diff --git a/test/lager_slow_backend.erl b/test/lager_slow_backend.erl index cd87dc3..19459ac 100644 --- a/test/lager_slow_backend.erl +++ b/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}.