From 6d7d1cc11d4b4bad7b00c2cbd9fdc1313b78dd71 Mon Sep 17 00:00:00 2001 From: snaky Date: Mon, 26 Nov 2012 12:40:25 +0400 Subject: [PATCH 1/6] Specify node in the default formatter --- src/lager_default_formatter.erl | 2 ++ 1 file changed, 2 insertions(+) diff --git a/src/lager_default_formatter.erl b/src/lager_default_formatter.erl index cbe614f..cb111eb 100644 --- a/src/lager_default_formatter.erl +++ b/src/lager_default_formatter.erl @@ -78,6 +78,8 @@ output(date,Msg) -> output(time,Msg) -> {_D, T} = lager_msg:timestamp(Msg), T; +output(node,Msg) -> + atom_to_list(node()); output(severity,Msg) -> atom_to_list(lager_msg:severity(Msg)); output(Prop,Msg) when is_atom(Prop) -> From 6ee1113ec0d8cd9dde4feacf1e1bade749f35057 Mon Sep 17 00:00:00 2001 From: Alexander Ovchinnikov Date: Tue, 9 Jul 2013 10:10:14 +0400 Subject: [PATCH 2/6] lager_uril.erl: validate_trace and trace acc modified to accept more filter expressions --- src/lager_util.erl | 44 +++++++++++++++++++++++--------------------- 1 file changed, 23 insertions(+), 21 deletions(-) diff --git a/src/lager_util.erl b/src/lager_util.erl index ae88d19..6d71944 100644 --- a/src/lager_util.erl +++ b/src/lager_util.erl @@ -388,20 +388,17 @@ validate_trace({Filter, Level, Destination}) when is_tuple(Filter); is_list(Filt validate_trace(_) -> {error, invalid_trace}. -validate_trace_filter(Filter) when is_tuple(Filter), is_atom(element(1, Filter)) =:= false -> - false; -validate_trace_filter(Filter) -> - case lists:all(fun({Key, '*'}) when is_atom(Key) -> true; - ({Key, _Value}) when is_atom(Key) -> true; - ({Key, '=', _Value}) when is_atom(Key) -> true; - ({Key, '<', _Value}) when is_atom(Key) -> true; - ({Key, '>', _Value}) when is_atom(Key) -> true; - (_) -> false end, Filter) of - true -> - true; - _ -> - false - end. +validate_trace_filter(Filter) when is_list(Filter) -> + lists:all(fun validate_trace_filter/1, Filter); +validate_trace_filter({Key, '*'}) when is_atom(Key) -> true; +validate_trace_filter({any, L}) when is_list(L) -> lists:all(fun validate_trace_filter/1, L); +validate_trace_filter({all, L}) when is_list(L) -> lists:all(fun validate_trace_filter/1, L); +validate_trace_filter({null, Bool}) when is_boolean(Bool) -> true; +validate_trace_filter({Key, _Value}) when is_atom(Key) -> true; +validate_trace_filter({Key, '=', _Value}) when is_atom(Key) -> true; +validate_trace_filter({Key, '<', _Value}) when is_atom(Key) -> true; +validate_trace_filter({Key, '>', _Value}) when is_atom(Key) -> true; +validate_trace_filter(_) -> false. trace_all(Query) -> glc:all(trace_acc(Query)). @@ -413,18 +410,23 @@ trace_acc(Query) -> trace_acc(Query, []). trace_acc([], Acc) -> - lists:reverse(Acc); + lists:reverse(Acc); +trace_acc([{any, L}|T], Acc) -> + trace_acc(T, [glc:any(L)|Acc]); +trace_acc([{all, L}|T], Acc) -> + trace_acc(T, [glc:all(L)|Acc]); +trace_acc([{null, Bool}|T], Acc) -> + trace_acc(T, [glc:null(Bool)|Acc]); trace_acc([{Key, '*'}|T], Acc) -> - trace_acc(T, [glc:wc(Key)|Acc]); + trace_acc(T, [glc:wc(Key)|Acc]); trace_acc([{Key, Val}|T], Acc) -> - trace_acc(T, [glc:eq(Key, Val)|Acc]); + trace_acc(T, [glc:eq(Key, Val)|Acc]); trace_acc([{Key, '=', Val}|T], Acc) -> - trace_acc(T, [glc:eq(Key, Val)|Acc]); + trace_acc(T, [glc:eq(Key, Val)|Acc]); trace_acc([{Key, '>', Val}|T], Acc) -> - trace_acc(T, [glc:gt(Key, Val)|Acc]); + trace_acc(T, [glc:gt(Key, Val)|Acc]); trace_acc([{Key, '<', Val}|T], Acc) -> - trace_acc(T, [glc:lt(Key, Val)|Acc]). - + trace_acc(T, [glc:lt(Key, Val)|Acc]). check_traces(_, _, [], Acc) -> lists:flatten(Acc); From e697038a84981101b360d2ed9907f6ec9a6ec3ca Mon Sep 17 00:00:00 2001 From: Alexander Ovchinnikov Date: Tue, 9 Jul 2013 12:30:21 +0400 Subject: [PATCH 3/6] Revert "Specify node in the default formatter" This reverts commit 6d7d1cc11d4b4bad7b00c2cbd9fdc1313b78dd71. --- src/lager_default_formatter.erl | 2 -- 1 file changed, 2 deletions(-) diff --git a/src/lager_default_formatter.erl b/src/lager_default_formatter.erl index 0b62371..312f6a0 100644 --- a/src/lager_default_formatter.erl +++ b/src/lager_default_formatter.erl @@ -84,8 +84,6 @@ output(date,Msg) -> output(time,Msg) -> {_D, T} = lager_msg:datetime(Msg), T; -output(node,Msg) -> - atom_to_list(node()); output(severity,Msg) -> atom_to_list(lager_msg:severity(Msg)); output(Prop,Msg) when is_atom(Prop) -> From 12433c0deca18a7475215b01f226a213cbdc2b09 Mon Sep 17 00:00:00 2001 From: Paul Khusainov Date: Fri, 2 Aug 2013 13:06:58 +0400 Subject: [PATCH 4/6] Load default_tracer before backends --- src/lager_app.erl | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/lager_app.erl b/src/lager_app.erl index d169f80..0195c7d 100644 --- a/src/lager_app.erl +++ b/src/lager_app.erl @@ -62,6 +62,8 @@ start(_StartType, _StartArgs) -> throw({error, bad_config}) end, + lager_util:trace_filter(none), + Handlers = case application:get_env(lager, handlers) of undefined -> [{lager_console_backend, info}, @@ -113,8 +115,6 @@ start(_StartType, _StartArgs) -> end end, - lager_util:trace_filter(none), - {ok, Pid, SavedHandlers}. From efb6a0975076581459028dd2dac57a468b10e445 Mon Sep 17 00:00:00 2001 From: Mark Allen Date: Thu, 16 Feb 2017 22:46:02 -0600 Subject: [PATCH 5/6] Add new filter expressions to README --- README.md | 28 ++++++++++++++++++++++++++-- 1 file changed, 26 insertions(+), 2 deletions(-) diff --git a/README.md b/README.md index b7508a5..393274d 100644 --- a/README.md +++ b/README.md @@ -538,7 +538,8 @@ second argument if desired. You can also specify multiple expressions in a filter, or use the `*` atom as a wildcard to match any message that has that attribute, regardless of its -value. +value. You may also use the special value `!` to mean, only select if this +key is **not** present. Tracing to an existing logfile is also supported (but see **Multiple sink support** below): @@ -566,13 +567,17 @@ data-type that serializes well. To trace by pid, use the pid as a string: lager:trace_console([{pid, "<0.410.0>"}]) ``` -As of lager 2.0, you can also use a 3 tuple while tracing, where the second +### Filter expressions +As of lager 3.3.1, you can also use a 3 tuple while tracing where the second element is a comparison operator. The currently supported comparison operators are: * `<` - less than +* `=<` - less than or equal * `=` - equal to +* `!=` - not equal to * `>` - greater than +* `>=` - greater than or equal ```erlang lager:trace_console([{request, '>', 117}, {request, '<', 120}]) @@ -580,6 +585,25 @@ lager:trace_console([{request, '>', 117}, {request, '<', 120}]) Using `=` is equivalent to the 2-tuple form. +### Filter composition +As of lager 3.3.1 you may also use the special filter composition keys of +`all` or `any`. For example the filter example above could be +expressed as: + +```erlang +lager:trace_console([{all, [{request, '>', 117}, {request, '<', 120}]}]) +``` + +`any` has the effect of "OR style" logical evaluation between filters; `all` +means "AND style" logical evaluation between filters. These compositional filters +expect a list of additional filter expressions as their values. + +### Null filters +The `null` filter has a special meaning. A filter of `{null, false}` acts as +a black hole; nothing is passed through. A filter of `{null, true}` means +*everything* passes through. No other values for the null filter are valid and +will be rejected. + ### Multiple sink support If using multiple sinks, there are limitations on tracing that you From 940ca76069a4b940a50977c7e1a198b15a90d529 Mon Sep 17 00:00:00 2001 From: Mark Allen Date: Mon, 27 Feb 2017 12:19:24 -0600 Subject: [PATCH 6/6] Add unit tests --- test/lager_test_backend.erl | 22 +++++++++++++++++++++- 1 file changed, 21 insertions(+), 1 deletion(-) diff --git a/test/lager_test_backend.erl b/test/lager_test_backend.erl index 25cb2e4..0e5df7a 100644 --- a/test/lager_test_backend.erl +++ b/test/lager_test_backend.erl @@ -210,7 +210,7 @@ lager_test_() -> }, {"unsafe logging with args works", fun() -> - lager:warning("test message ~p", [self()]), + lager:warning_unsafe("test message ~p", [self()]), ?assertEqual(1, count()), {Level, _Time, Message,_Metadata} = pop(), ?assertMatch(Level, lager_util:level_to_num(warning)), @@ -479,6 +479,26 @@ lager_test_() -> lager:clear_all_traces(), lager:info([{requestid, 6}], "hello world"), ?assertEqual(10, count()), + lager:clear_all_traces(), + lager:trace(?MODULE, [{requestid, '>=', 5}, {requestid, '=<', 7}], debug), + lager:info([{requestid, 4}], "nope!"), + lager:info([{requestid, 5}], "hello world"), + lager:info([{requestid, 7}], "hello world again"), + ?assertEqual(12, count()), + lager:clear_all_traces(), + lager:trace(?MODULE, [{foo, '!=', bar}]), + lager:info([{foo, bar}], "hello world"), + ?assertEqual(12, count()), + lager:info([{foo, baz}], "blarg"), + ?assertEqual(13, count()), + lager:clear_all_traces(), + lager:trace(?MODULE, [{all, [{foo, '=', bar}, {null, false}]}]), + lager:info([{foo, bar}], "should not be logged"), + ?assertEqual(13, count()), + lager:clear_all_traces(), + lager:trace(?MODULE, [{any, [{foo, '=', bar}, {null, true}]}]), + lager:info([{foo, qux}], "should be logged"), + ?assertEqual(14, count()), ok end },