% %CopyrightBegin%
%  
%       |   /¯\ /¯_ /¯_ |_¯ |¯\     |¯¯  | |   ¯|¯ |_¯ |¯\  (`              
%       |__ \_/ \_/ \_/ |__ |¯\ ___ |¯   | |__  |  |__ |¯\ \_)  .   E  R  L 
%\     
%%
%% Copyright Ericsson AB 2017-2018. All Rights Reserved.
%%
%%——————————————————————————————————————————————
%% Whitespace Beautified by ScriptCulture © JANUARY 2019
%% Sit Back · Feet Up · Learn Erlang        ¯¯¯¯¯¯¯
%% For use as a reference only
%% www.scriptculture.com
%% Not check-summed 
%% kernel-6.1.1 ——————————————————————————————————
%%
%% Licensed under the Apache License, 
%% Version 2.0 (the "License"); you may 
%% not use this file except in compliance 
%% with the License. You may obtain a copy 
%% of the License at:
%%
%%     http://www.apache.org/licenses/LICENSE-2.0
%%
%% Unless required by 
%% applicable law or agreed to in writing, software
%% distributed under the License is distributed 
%% on an "AS IS" BASIS, WITHOUT WARRANTIES 
%% OR CONDITIONS OF ANY KIND, either 
%% express or implied. See the 
%% License for the specific 
%% language governing 
%% permissions and
%% limitations 
%% under the 
%% License.
%%%%%%%
%%%%
%%       
%       
%        
%%       
%%%     
%% %CopyrightEnd%   
-module(logger_filters).

-export([ domain/2    % Provides a way of filtering log events based on a domain field in Metadata.
        , level/2     % Provides a way of filtering log events based on the log level.
        , progress/2  % Stops or allows progress reports from supervisor and application_controller.
        , remote_gl/2 % Stops or allows log events originating from a process that has its 
        ]).           %                                      group leader on a remote node.
 
-include("logger_internal.hrl").

-define(IS_ACTION(A), (A==log orelse A==stop)).






           %%·% DOMAIN / 2 %·%% 

          -spec domain(LogEvent,Extra) -> logger:filter_return() 
           when
           LogEvent    ::           logger:log_event(),
           Extra       :: {Action,Compare,MatchDomain},
           Action      :: log 
                        | stop                        , % If stop is returned, the log event is immediately discarded.
           Compare     :: super 
                        | sub 
                        | equal
                        | not_equal 
                        | undefined                   ,
           MatchDomain ::               list( atom() ).

%  This filter provides a way of filtering 
%  log events based on a domain field in Metadata. 
%  This field is optional, and the purpose of using 
%  it is to group log events from, for example, a specific functional area. 
%  This allows filtering or other specialized treatment in a Logger handler.
%  
%  A domain field must be a list of atoms, 
%  creating smaller and more specialized domains as the list grows longer. 
%  The greatest domain is [], which comprises all possible domains.
%  
%  For example, consider the following domains:
%  
%               D1 = [otp]
%               D2 = [otp, sasl]
%               D1 is the greatest of the two, 
%               and is said to be a super-domain of D2. 
%               D2 is a sub-domain D1. Both D1 and D2 are sub-domains of [].
%  
%             The above domains are used for logs originating from Erlang/OTP. 
%               D1 specifies that the log event comes from Erlang/OTP in general, 
%             & D2 indicates that the log event is a so called SASL report.
%  
%  The Extra parameter to the domain/2 function is specified when adding 
%  the filter via logger:add_primary_filter/2 or logger:add_handler_filter/3.
%  
%  The filter compares the value of the domain field in the log event's 
%                                                               metadata (Domain) 
%                                                       against MatchDomain. 
%   The filter matches if the value of Compare is:
%  
%  sub
%     and Domain is equal to or a sub-domain of MatchDomain, 
%     that is, if MatchDomain is a prefix of Domain.
%  
%  super
%       and Domain is equal to or a super-domain of MatchDomain, 
%       that is, if Domain is a prefix of MatchDomain.
%  
%  equal
%       and Domain is equal to MatchDomain.
%  
%  not_equal
%           and Domain differs from MatchDomain, or if there is no domain field in metadata.
%  
%  undefined
%           and there is no domain field in metadata. 
%           In this case MatchDomain must be set to [].
%  
%   If the filter matches and Action is log, the log event is allowed. 
%   If the filter matches and Action is stop, the log event is stopped.
%   
%   If the filter does not match, it returns ignore,
%       meaning that other filters, or the value of the 
%       configuration parameter filter_default, 
%       decide if the event is allowed or not.
%   
%   Log events that do not contain any domain field, 
%   match only when Compare is equal to undefined or not_equal.
%  
%   Example: stop all events with domain [otp, sasl | _]
%  
%                   logger:set_handler_config(h1, filter_default, log). %--- this is the default
%     Filter = {fun logger_filters:domain/2, {stop, sub, [otp, sasl]}}.
%                   logger:add_handler_filter(h1, no_sasl, Filter).
%                    ok

domain( #{ meta := Meta } = LogEvent
       , {Action,Compare,MatchDomain}
        )
    when 
    ?IS_ACTION(Action) andalso
       ( 
        Compare==super orelse
        Compare==sub orelse
        Compare==equal orelse
        Compare==not_equal orelse
        Compare==undefined
       )  
 andalso
        is_list(MatchDomain) 
        ->
          filter_domain( Compare
                        , Meta
                         , MatchDomain
                          ,on_match(Action,LogEvent)
                           )

;domain(LogEvent,Extra) 
  ->
    erlang:error(badarg,[LogEvent,Extra]).









          -spec level(LogEvent,Extra) -> logger:filter_return() 
           when
           LogEvent   ::           logger:log_event(),
           Extra      :: {Action,Operator,MatchLevel},
           Action     :: log 
                       | stop                        ,
           Operator   :: neq 
                       | eq 
                       | lt 
                       | gt 
                       | lteq 
                       | gteq                        ,
           MatchLevel ::               logger:level().

%   This filter provides a way of filtering log events based on the log level. 
%   It matches log events by comparing the log level with a specified MatchLevel
%   
%   The Extra parameter is specified when adding 
%   the filter via logger:add_primary_filter/2 
%               or logger:add_handler_filter/3.
%   
%   The filter compares the value of the event's 
%   log level (Level) to MatchLevel by calling: logger:compare_levels(Level, MatchLevel). 
%   The filter matches if the value of Operator is:
%           
%           neq
%              and the compare function returns lt or gt.
%           
%           eq
%              and the compare function returns eq.
%           
%           lt
%              and the compare function returns lt.
%           
%           gt
%              and the compare function returns gt.
%           
%           lteq
%              and the compare function returns lt or eq.
%           
%           gteq
%           and the compare function returns gt or eq.
%           
%   If the filter matches and Action is log , the log event is allowed. 
%   If the filter matches and Action is stop, the log event is stopped.
%   
%   If the filter does not match, it returns ignore, 
%   meaning that other filters, or the value of the configuration 
%   parameter filter_default, will decide if the event is allowed or not.
%   
%   Example: only allow debug level log events
%   
%             logger:set_handler_config(h1, filter_default, stop).
%             Filter = {fun logger_filters:level/2, {log, eq, debug}}.
%             logger:add_handler_filter(h1, debug_only, Filter).
%             ok

level( #{level := L1} = LogEvent, {Action,Op,L2} )
  when 
  ?IS_ACTION(Action) andalso 
       (Op==neq orelse
        Op==eq orelse
        Op==lt orelse
        Op==gt orelse
        Op==lteq orelse
        Op==gteq) andalso
       ?IS_LEVEL(L2) ->
                        filter_level(Op,L1,L2,on_match(Action,LogEvent))

%   This filter matches all progress reports from 
%            supervisor and application_controller.
%   
%   If Extra is log , the progress reports are allowed. 
%   If Extra is stop, the progress reports are stopped.
%   
%   The filter returns ignore for all other log events.

;level(                 LogEvent,      Extra    ) 
->
   erlang:error(badarg,[LogEvent,      Extra  ] ).









          -spec progress(LogEvent,Extra) -> logger:filter_return() 
           when
           LogEvent :: logger:log_event(),
           Extra    :: log 
                     | stop.

%   This filter matches all events originating from a 
%   process that has its group leader on a remote node.
%   
%   If Extra is log, the matching events are allowed. 
%   If Extra is stop, the matching events are stopped.
%   
%   The filter returns ignore for all other log events.

progress( LogEvent,Action) 
   when ?IS_ACTION(Action) ->
                              filter_progress(LogEvent,on_match(Action,LogEvent))

;progress(LogEvent,Action) ->
                              erlang:error(badarg,[LogEvent,Action]).




          -spec remote_gl(LogEvent,Extra) -> logger:filter_return() 
           when
           LogEvent :: logger:log_event(),
           Extra    :: log 
                     | stop              .

remote_gl( LogEvent,Action) 
    when ?IS_ACTION(Action) ->
                              filter_remote_gl(LogEvent,on_match(Action,LogEvent))

;remote_gl(LogEvent,Action) ->
                              erlang:error(badarg,[LogEvent,Action]).



%%%-----------------------------------------------------------------
%%% Internal
filter_domain(  super    ,#{domain:=Domain},MatchDomain,OnMatch) 
                        ->
                          is_prefix(Domain ,MatchDomain,OnMatch)


;filter_domain( sub      ,#{domain:=Domain},MatchDomain,OnMatch) 
  ->
    is_prefix(MatchDomain,Domain,OnMatch)


;filter_domain( equal    ,#{domain:=Domain},     Domain,OnMatch) 
  ->
    OnMatch

;filter_domain( not_equal,#{domain:=Domain},MatchDomain,OnMatch)
                              when Domain
                                       =/= MatchDomain->
                                                       OnMatch

;filter_domain(  Compare ,      Meta       ,      _    ,OnMatch) 
  ->
    case
    maps:is_key( domain, Meta) 
                           of
        false when 
        Compare==undefined
       ;Compare==not_equal -> OnMatch
       ;      _            -> ignore
                          end
                            .

is_prefix(D1,D2,OnMatch) 
  when 
  is_list(D1)
    ,is_list(D2) ->
                   case 
                   lists:prefix(D1,D2) 
                                   of
                              true -> OnMatch
                            ;false -> ignore
                                  end

;is_prefix(_,_,_) ->
                    ignore.





filter_level(   Op    , L1,L2 , OnMatch) ->
  case 
  logger:compare_levels(L1,L2) 
                          of
        eq when Op==eq; Op==lteq; Op==gteq -> OnMatch;
        lt when Op==lt; Op==lteq; Op== neq -> OnMatch;
        gt when Op==gt; Op==gteq; Op== neq -> OnMatch;
                                   _       ->  ignore
                         end
                           .





filter_progress( #{msg := {report,#{ label:={_,progress} }}} , OnMatch) 
                                                             ->
                                                               OnMatch

;filter_progress(_,_)->
                        ignore.




filter_remote_gl( #{ meta := #{gl:=GL} }, OnMatch) 
                         when node(GL)
                          =/= node() ->
                                       OnMatch


;filter_remote_gl(_,_)->
                         ignore.


on_match( log ,LogEvent) -> LogEvent
;on_match(stop,   _    ) -> stop
.