Add support for group leader strategies

The default strategy is 'handle', for backwards compatibility,
and is set to that if otherwise undefined.  Other strategies
include 'mirror' and 'ignore'.
   Before when the error_logger was removed when lager starts up,
some functionality was chopped off, such as forwarding io to the
caller's group leader, this is supported with the strategy 'ignore'
and is similar to how the io system in erlang works traditionally.
   Setting the 'mirror' strategy will essentially combine the other
two strategies such that the remote node reply is forwarded and also
handled locally. This is in some cases more in-line with what some
people might expect, efficiency may vary.
   The traditional 'ignore' approach is more suitable and most likely
originally intended for embedded terminals where 'mirror'-ing the io
is largely unnecessary.

src/error_logger_lager_h.erl

@@ -41,7 +41,9 @@
         %% the current second
         lasttime = os:timestamp() :: erlang:timestamp(),
         %% count of dropped messages this second
-        dropped = 0 :: non_neg_integer()
+        dropped = 0 :: non_neg_integer(),
+        %% group leader strategy
+        groupleader_strategy :: handle | ignore | mirror
     }).
 
 -define(LOGMSG(Level, Pid, Msg),
@@ -74,16 +76,27 @@ set_high_water(N) ->
     gen_event:call(error_logger, ?MODULE, {set_high_water, N}, infinity).
 
 -spec init(any()) -> {ok, #state{}}.
-init([HighWaterMark]) ->
-    {ok, #state{hwm=HighWaterMark}}.
+init([HighWaterMark, GlStrategy]) ->
+    {ok, #state{hwm=HighWaterMark, groupleader_strategy=GlStrategy}}.
 
 handle_call({set_high_water, N}, State) ->
     {ok, ok, State#state{hwm = N}};
 handle_call(_Request, State) ->
     {ok, unknown_call, State}.
 
-handle_event(Event, State) ->
+handle_event(Event, #state{groupleader_strategy=GlStrategy0}=State) ->
     case check_hwm(State) of
+        {true, NewState} when is_pid(element(2, Event)) ->
+            case element(2, Event) of
+                GL when node(GL) =/= node(), GlStrategy0 =:= ignore ->
+                    gen_event:notify({error_logger, node(GL)}, Event),
+                    {ok, State};
+                GL when node(GL) =/= node(), GlStrategy0 =:= mirror ->
+                    gen_event:notify({error_logger, node(GL)}, Event),
+                    log_event(Event, NewState);
+                _ ->
+                    log_event(Event, NewState)
+            end;
         {true, NewState} ->
             log_event(Event, NewState);
         {false, NewState} ->

src/lager_app.erl

@@ -104,7 +104,22 @@ start(_StartType, _StartArgs) ->
                         WhiteList0
                 end,
 
-                case supervisor:start_child(lager_handler_watcher_sup, [error_logger, error_logger_lager_h, [HighWaterMark]]) of
+                GlStrategy = case application:get_env(lager, error_logger_groupleader_strategy) of
+                    undefined ->
+                        handle;
+                    {ok, GlStrategy0} when 
+                            GlStrategy0 =:= handle;
+                            GlStrategy0 =:= ignore;
+                            GlStrategy0 =:= mirror ->
+                        GlStrategy0;
+                    {ok, BadGlStrategy} ->
+                        error_logger:error_msg(
+                          "Invalid value for 'error_logger_groupleader_strategy': ~p~n",
+                          [BadGlStrategy]),
+                        throw({error, bad_config})
+                end,
+
+                case supervisor:start_child(lager_handler_watcher_sup, [error_logger, error_logger_lager_h, [HighWaterMark, GlStrategy]]) of
                     {ok, _} ->
                         [begin error_logger:delete_report_handler(X), X end ||
                             X <- gen_event:which_handlers(error_logger) -- [error_logger_lager_h | WhiteList]];