Merge branch 'adt-syslog-comparison-flags'

include/lager.hrl

@@ -20,15 +20,15 @@
 -define(LEVELS,
     [debug, info, notice, warning, error, critical, alert, emergency, none]).
 
--define(DEBUG, 7).
--define(INFO, 6).
--define(NOTICE, 5).
--define(WARNING, 4).
--define(ERROR, 3).
--define(CRITICAL, 2).
--define(ALERT, 1).
--define(EMERGENCY, 0).
--define(LOG_NONE, -1).
+-define(DEBUG, 128).
+-define(INFO, 64).
+-define(NOTICE, 32).
+-define(WARNING, 16).
+-define(ERROR, 8).
+-define(CRITICAL, 4).
+-define(ALERT, 2).
+-define(EMERGENCY, 1).
+-define(LOG_NONE, 0).
 
 -define(LEVEL2NUM(Level),
     case Level of
@@ -55,7 +55,7 @@
     end).
 
 -define(SHOULD_LOG(Level),
-    lager_util:level_to_num(Level) =< element(1, lager_config:get(loglevel, {?LOG_NONE, []}))).
+    (lager_util:level_to_num(Level) band element(1, lager_config:get(loglevel, {?LOG_NONE, []}))) /= 0).
 
 -define(NOTIFY(Level, Pid, Format, Args),
     gen_event:notify(lager_event, {log, lager_msg:new(io_lib:format(Format, Args),

src/lager.erl

@@ -23,7 +23,7 @@
 %% API
 -export([start/0,
         log/3, log/4,
-        trace_file/2, trace_file/3, trace_console/1, trace_console/2,
+        trace/2, trace/3, trace_file/2, trace_file/3, trace_console/1, trace_console/2,
         clear_all_traces/0, stop_trace/1, status/0,
         get_loglevel/1, set_loglevel/2, set_loglevel/3, get_loglevels/0,
         minimum_loglevel/1, posix_error/1,
@@ -61,21 +61,24 @@ dispatch_log(Severity, Metadata, Format, Args, Size) when is_atom(Severity)->
         Pid ->
             {LevelThreshold,TraceFilters} = lager_config:get(loglevel,{?LOG_NONE,[]}),
             SeverityAsInt=lager_util:level_to_num(Severity),
-            Destinations = case TraceFilters of 
-                [] -> [];
-                _ -> 
-                    lager_util:check_traces(Metadata,SeverityAsInt,TraceFilters,[])
-            end,
-            case (LevelThreshold >= SeverityAsInt orelse Destinations =/= []) of
-                true -> 
+            case (LevelThreshold band SeverityAsInt) /= 0 of
+                true ->
+                    Destinations = case TraceFilters of
+                        [] ->
+                            [];
+                        _ ->
+                            lager_util:check_traces(Metadata,SeverityAsInt,TraceFilters,[])
+                    end,
                     Timestamp = lager_util:format_time(),
-                    Msg=case Args of 
-                        A when is_list(A) ->safe_format_chop(Format,Args,Size);
-                        _ -> Format
+                    Msg = case Args of
+                        A when is_list(A) ->
+                            safe_format_chop(Format,Args,Size);
+                        _ ->
+                            Format
                     end,
                     gen_event:sync_notify(Pid, {log, lager_msg:new(Msg, Timestamp,
                                 Severity, Metadata, Destinations)});
-                _ -> 
+                _ ->
                     ok
             end
     end.
@@ -107,7 +110,7 @@ trace_file(File, Filter, Level) ->
                 false ->
                     %% install the handler
                     supervisor:start_child(lager_handler_watcher_sup,
-                        [lager_event, {lager_file_backend, File}, {File, none}]);
+                        [lager_event, {lager_file_backend, File}, {File, Level}]);
                 _ ->
                     {ok, exists}
             end,
@@ -117,7 +120,8 @@ trace_file(File, Filter, Level) ->
                 {MinLevel, Traces} = lager_config:get(loglevel),
                 case lists:member(Trace, Traces) of
                   false ->
-                    lager_config:set(loglevel, {MinLevel, [Trace|Traces]});
+                    {_, {mask, TraceMask}, _} = Trace,
+                    lager_config:set(loglevel, {MinLevel bor TraceMask, [Trace|Traces]});
                   _ ->
                     ok
                 end,
@@ -133,13 +137,20 @@ trace_console(Filter) ->
     trace_console(Filter, debug).
 
 trace_console(Filter, Level) ->
-    Trace0 = {Filter, Level, lager_console_backend},
+    trace(lager_console_backend, Filter, Level).
+
+trace(Backend, Filter) ->
+    trace(Backend, Filter, debug).
+
+trace(Backend, Filter, Level) ->
+    Trace0 = {Filter, Level, Backend},
     case lager_util:validate_trace(Trace0) of
         {ok, Trace} ->
             {MinLevel, Traces} = lager_config:get(loglevel),
             case lists:member(Trace, Traces) of
                 false ->
-                    lager_config:set(loglevel, {MinLevel, [Trace|Traces]});
+                    {_, {mask, TraceMask}, _} = Trace,
+                    lager_config:set(loglevel, {MinLevel bor TraceMask, [Trace|Traces]});
                 _ -> ok
             end,
             {ok, Trace};
@@ -148,8 +159,9 @@ trace_console(Filter, Level) ->
     end.
 
 stop_trace({_Filter, _Level, Target} = Trace) ->
-    {MinLevel, Traces} = lager_config:get(loglevel),
+    {_, Traces} = lager_config:get(loglevel),
     NewTraces =  lists:delete(Trace, Traces),
+    MinLevel = minimum_loglevel(get_loglevels() ++ get_trace_levels(NewTraces)),
     lager_config:set(loglevel, {MinLevel, NewTraces}),
     case get_loglevel(Target) of
         none ->
@@ -166,7 +178,7 @@ stop_trace({_Filter, _Level, Target} = Trace) ->
     ok.
 
 clear_all_traces() ->
-    {MinLevel, _Traces} = lager_config:get(loglevel),
+    MinLevel = minimum_loglevel(get_loglevels()),
     lager_config:set(loglevel, {MinLevel, []}),
     lists:foreach(fun(Handler) ->
           case get_loglevel(Handler) of
@@ -202,8 +214,8 @@ status() ->
 set_loglevel(Handler, Level) when is_atom(Level) ->
     Reply = gen_event:call(lager_event, Handler, {set_loglevel, Level}, infinity),
     %% recalculate min log level
-    MinLog = minimum_loglevel(get_loglevels()),
     {_, Traces} = lager_config:get(loglevel),
+    MinLog = minimum_loglevel(get_loglevels() ++ get_trace_levels(Traces)),
     lager_config:set(loglevel, {MinLog, Traces}),
     Reply.
 
@@ -212,15 +224,17 @@ set_loglevel(Handler, Level) when is_atom(Level) ->
 set_loglevel(Handler, Ident, Level) when is_atom(Level) ->
     Reply = gen_event:call(lager_event, {Handler, Ident}, {set_loglevel, Level}, infinity),
     %% recalculate min log level
-    MinLog = minimum_loglevel(get_loglevels()),
     {_, Traces} = lager_config:get(loglevel),
+    MinLog = minimum_loglevel(get_loglevels() ++ get_trace_levels(Traces)),
     lager_config:set(loglevel, {MinLog, Traces}),
     Reply.
 
 %% @doc Get the loglevel for a particular backend. In the case that the backend
 %% has multiple identifiers, the lowest is returned
 get_loglevel(Handler) ->
     case gen_event:call(lager_event, Handler, get_loglevel, infinity) of
+        {mask, Mask} ->
+            erlang:hd(lager_util:mask_to_levels(Mask));
         X when is_integer(X) ->
             lager_util:num_to_level(X);
         Y -> Y
@@ -242,10 +256,18 @@ get_loglevels() ->
         Handler <- gen_event:which_handlers(lager_event)].
 
 %% @private
-minimum_loglevel([]) ->
-    -1; %% lower than any log level, logging off
 minimum_loglevel(Levels) ->
-    erlang:hd(lists:reverse(lists:sort(Levels))).
+    lists:foldl(fun({mask, Mask}, Acc) ->
+                Mask bor Acc;
+            (Level, Acc) when is_integer(Level) ->
+                {mask, Mask} = lager_util:config_to_mask(lager_util:num_to_level(Level)),
+                Mask bor Acc;
+            (_, Acc) ->
+                Acc
+        end, 0, Levels).
+
+get_trace_levels(Traces) ->
+    lists:map(fun({_, Level, _}) -> Level end, Traces).
 
 %% @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/lager_config.erl

@@ -36,7 +36,7 @@ new() ->
     %% 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
-    ets:insert_new(?TBL, {loglevel, {?DEBUG, []}}),
+    ets:insert_new(?TBL, {loglevel, {element(2, lager_util:config_to_mask(debug)), []}}),
     ok.
 
 

src/lager_console_backend.erl

@@ -43,12 +43,13 @@ init([Level, true]) -> % for backwards compatibility
 init([Level,false]) -> % for backwards compatibility
     init([Level,{lager_default_formatter,?TERSE_FORMAT}]);
 init([Level,{Formatter,FormatterConfig}])  when is_atom(Level), is_atom(Formatter)->
-    case lists:member(Level, ?LEVELS) of
-        true ->
-            {ok, #state{level=lager_util:level_to_num(Level), 
+   try lager_util:config_to_mask(Level) of
+        Levels ->
+            {ok, #state{level=Levels,
                     formatter=Formatter, 
-                    format_config=FormatterConfig}};
-        _ ->
+                    format_config=FormatterConfig}}
+    catch
+        _:_ ->
             {error, bad_log_level}
     end.
 
@@ -57,10 +58,11 @@ init([Level,{Formatter,FormatterConfig}])  when is_atom(Level), is_atom(Formatte
 handle_call(get_loglevel, #state{level=Level} = State) ->
     {ok, Level, State};
 handle_call({set_loglevel, Level}, State) ->
-    case lists:member(Level, ?LEVELS) of
-        true ->
-            {ok, ok, State#state{level=lager_util:level_to_num(Level)}};
-        _ ->
+   try lager_util:config_to_mask(Level) of
+        Levels ->
+            {ok, ok, State#state{level=Levels}}
+    catch
+        _:_ ->
             {ok, {error, bad_log_level}, State}
     end;
 handle_call(_Request, State) ->
@@ -133,7 +135,7 @@ console_log_test_() ->
                         unregister(user),
                         register(user, Pid),
                         erlang:group_leader(Pid, whereis(lager_event)),
-                        lager_config:set(loglevel, {?INFO, []}),
+                        lager_config:set(loglevel, {element(2, lager_util:config_to_mask(info)), []}),
                         lager:log(info, self(), "Test message"),
                         receive
                             {io_request, From, ReplyAs, {put_chars, unicode, Msg}} ->
@@ -152,7 +154,7 @@ console_log_test_() ->
                         register(user, Pid),
                         erlang:group_leader(Pid, whereis(lager_event)),
                         gen_event:add_handler(lager_event, lager_console_backend, [info, true]),
-                        lager_config:set(loglevel, {?INFO, []}),
+                        lager_config:set(loglevel, {element(2, lager_util:config_to_mask(info)), []}),
                         lager:info("Test message"),
                         lager:info("Test message"),
                         PidStr = pid_to_list(self()),
@@ -196,7 +198,7 @@ console_log_test_() ->
                         register(user, Pid),
                         gen_event:add_handler(lager_event, lager_console_backend, info),
                         erlang:group_leader(Pid, whereis(lager_event)),
-                        lager_config:set(loglevel, {?INFO, []}),
+                        lager_config:set(loglevel, {element(2, lager_util:config_to_mask(info)), []}),
                         lager:debug("Test message"),
                         receive
                             {io_request, From, ReplyAs, {put_chars, unicode, _Msg}} ->
@@ -224,7 +226,7 @@ console_log_test_() ->
                         unregister(user),
                         register(user, Pid),
                         gen_event:add_handler(lager_event, lager_console_backend, info),
-                        lager_config:set(loglevel, {?INFO, []}),
+                        lager_config:set(loglevel, {element(2, lager_util:config_to_mask(info)), []}),
                         erlang:group_leader(Pid, whereis(lager_event)),
                         lager:debug("Test message"),
                         receive
@@ -255,8 +257,67 @@ console_log_test_() ->
                                 ?assert(true)
                         end
                 end
+            },
+            {"blacklisting a loglevel works",
+                fun() ->
+                        Pid = spawn(F(self())),
+                        unregister(user),
+                        register(user, Pid),
+                        gen_event:add_handler(lager_event, lager_console_backend, info),
+                        lager_config:set(loglevel, {element(2, lager_util:config_to_mask(info)), []}),
+                        lager:set_loglevel(lager_console_backend, '!=info'),
+                        erlang:group_leader(Pid, whereis(lager_event)),
+                        lager:debug("Test message"),
+                        receive
+                            {io_request, From1, ReplyAs1, {put_chars, unicode, Msg1}} ->
+                                From1 ! {io_reply, ReplyAs1, ok},
+                                ?assertMatch([_, "[debug]", "Test message\r\n"], re:split(Msg1, " ", [{return, list}, {parts, 3}]))
+                        after
+                            1000 ->
+                                ?assert(false)
+                        end,
+                        %% info is blacklisted
+                        lager:info("Test message"),
+                        receive
+                            {io_request, From2, ReplyAs2, {put_chars, unicode, _Msg2}} ->
+                                From2 ! {io_reply, ReplyAs2, ok},
+                                ?assert(false)
+                        after
+                            500 ->
+                                ?assert(true)
+                        end
+                end
+            },
+            {"whitelisting a loglevel works",
+                fun() ->
+                        Pid = spawn(F(self())),
+                        unregister(user),
+                        register(user, Pid),
+                        gen_event:add_handler(lager_event, lager_console_backend, info),
+                        lager_config:set(loglevel, {element(2, lager_util:config_to_mask(info)), []}),
+                        lager:set_loglevel(lager_console_backend, '=debug'),
+                        erlang:group_leader(Pid, whereis(lager_event)),
+                        lager:debug("Test message"),
+                        receive
+                            {io_request, From1, ReplyAs1, {put_chars, unicode, Msg1}} ->
+                                From1 ! {io_reply, ReplyAs1, ok},
+                                ?assertMatch([_, "[debug]", "Test message\r\n"], re:split(Msg1, " ", [{return, list}, {parts, 3}]))
+                        after
+                            1000 ->
+                                ?assert(false)
+                        end,
+                        %% info is blacklisted
+                        lager:error("Test message"),
+                        receive
+                            {io_request, From2, ReplyAs2, {put_chars, unicode, _Msg2}} ->
+                                From2 ! {io_reply, ReplyAs2, ok},
+                                ?assert(false)
+                        after
+                            500 ->
+                                ?assert(true)
+                        end
+                end
             }
-
         ]
     }.
 
@@ -278,7 +339,12 @@ set_loglevel_test_() ->
                 fun() ->
                         ?assertEqual(info, lager:get_loglevel(lager_console_backend)),
                         lager:set_loglevel(lager_console_backend, debug),
-                        ?assertEqual(debug, lager:get_loglevel(lager_console_backend))
+                        ?assertEqual(debug, lager:get_loglevel(lager_console_backend)),
+                        lager:set_loglevel(lager_console_backend, '!=debug'),
+                        ?assertEqual(info, lager:get_loglevel(lager_console_backend)),
+                        lager:set_loglevel(lager_console_backend, '!=info'),
+                        ?assertEqual(debug, lager:get_loglevel(lager_console_backend)),
+                        ok
                 end
             },
             {"Get/set invalid loglevel test",