Merge branch 'maint'

11 files changed, 996 insertions, 178 deletions

diff --git a/lib/kernel/test/Makefile b/lib/kernel/test/Makefile
index 4a86265a4a..8a6ffe7e72 100644
--- a/lib/kernel/test/Makefile
+++ b/lib/kernel/test/Makefile
@@ -76,8 +76,11 @@ MODULES= \
 	logger_filters_SUITE \
 	logger_formatter_SUITE \
 	logger_legacy_SUITE \
+	logger_olp_SUITE \
+	logger_proxy_SUITE \
 	logger_simple_h_SUITE \
 	logger_std_h_SUITE \
+	logger_stress_SUITE \
 	logger_test_lib \
 	os_SUITE \
 	pg2_SUITE \
diff --git a/lib/kernel/test/kernel_bench.spec b/lib/kernel/test/kernel_bench.spec
index 4de133f21b..898ceb59e0 100644
--- a/lib/kernel/test/kernel_bench.spec
+++ b/lib/kernel/test/kernel_bench.spec
@@ -1,2 +1,3 @@
 {groups,"../kernel_test",zlib_SUITE,[bench]}.
 {groups,"../kernel_test",file_SUITE,[bench]}.
+{suites,"../kernel_test",[logger_stress_SUITE]}.
diff --git a/lib/kernel/test/logger.cover b/lib/kernel/test/logger.cover
index 960bc0abff..9691aa295e 100644
--- a/lib/kernel/test/logger.cover
+++ b/lib/kernel/test/logger.cover
@@ -4,9 +4,12 @@
             logger_backend,
             logger_config,
             logger_disk_log_h,
-            logger_h_common,
             logger_filters,
             logger_formatter,
+            logger_handler_watcher,
+            logger_h_common,
+            logger_olp,
+            logger_proxy,
             logger_server,
             logger_simple_h,
             logger_std_h,
diff --git a/lib/kernel/test/logger.spec b/lib/kernel/test/logger.spec
index 1ab90b3e93..3aec37951d 100644
--- a/lib/kernel/test/logger.spec
+++ b/lib/kernel/test/logger.spec
@@ -7,5 +7,7 @@
                            logger_filters_SUITE,
                            logger_formatter_SUITE,
                            logger_legacy_SUITE,
+                           logger_olp_SUITE,
+                           logger_proxy_SUITE,
                            logger_simple_h_SUITE,
                            logger_std_h_SUITE]}.
diff --git a/lib/kernel/test/logger_disk_log_h_SUITE.erl b/lib/kernel/test/logger_disk_log_h_SUITE.erl
index 87b8250781..9bbec42de8 100644
--- a/lib/kernel/test/logger_disk_log_h_SUITE.erl
+++ b/lib/kernel/test/logger_disk_log_h_SUITE.erl
@@ -24,6 +24,7 @@
 -include_lib("common_test/include/ct.hrl").
 -include_lib("kernel/include/logger.hrl").
 -include_lib("kernel/src/logger_internal.hrl").
+-include_lib("kernel/src/logger_olp.hrl").
 -include_lib("kernel/src/logger_h_common.hrl").
 -include_lib("stdlib/include/ms_transform.hrl").
 -include_lib("kernel/include/file.hrl").
@@ -97,7 +98,6 @@ all() ->
      formatter_fail,
      config_fail,
      bad_input,
-     info_and_reset,
      reconfig,
      sync,
      disk_log_full,
@@ -306,9 +306,9 @@ logging(cleanup, _Config) ->
 filter_config(_Config) ->
     ok = logger:add_handler(?MODULE,logger_disk_log_h,#{}),
     {ok,#{config:=HConfig}=Config} = logger:get_handler_config(?MODULE),
-    HConfig = maps:without([handler_pid,mode_tab],HConfig),
+    HConfig = maps:without([olp],HConfig),
 
-    FakeFullHConfig = HConfig#{handler_pid=>self(),mode_tab=>erlang:make_ref()},
+    FakeFullHConfig = HConfig#{olp=>{regname,self(),erlang:make_ref()}},
     #{config:=HConfig} =
         logger_disk_log_h:filter_config(Config#{config=>FakeFullHConfig}),
     ok.
@@ -351,9 +351,7 @@ errors(Config) ->
     %% Read-only fields may (accidentially) be included in the change,
     %% but it won't take effect
     {ok,C} = logger:get_handler_config(Name1),
-    ok = logger:set_handler_config(Name1,config,
-                                   #{handler_pid=>self(),
-                                     mode_tab=>erlang:make_ref()}),
+    ok = logger:set_handler_config(Name1,config,#{olp=>dummyvalue}),
     {ok,C} = logger:get_handler_config(Name1),
 
 
@@ -419,19 +417,16 @@ config_fail(_Config) ->
                              filter_default=>log,
                              formatter=>{?MODULE,self()}}),
 
-    {error,{handler_not_added,{invalid_config,logger_disk_log_h,
-                               {invalid_levels,#{drop_mode_qlen:=1}}}}} =
+    {error,{handler_not_added,{invalid_olp_levels,#{drop_mode_qlen:=1}}}} =
         logger:add_handler(?MODULE,logger_disk_log_h,
                            #{config => #{drop_mode_qlen=>1}}),
-    {error,{handler_not_added,{invalid_config,logger_disk_log_h,
-                               {invalid_levels,#{sync_mode_qlen:=43,
-                                                 drop_mode_qlen:=42}}}}} =
+    {error,{handler_not_added,{invalid_olp_levels,#{sync_mode_qlen:=43,
+                                                drop_mode_qlen:=42}}}} =
         logger:add_handler(?MODULE,logger_disk_log_h,
                            #{config => #{sync_mode_qlen=>43,
                                          drop_mode_qlen=>42}}),
-    {error,{handler_not_added,{invalid_config,logger_disk_log_h,
-                               {invalid_levels,#{drop_mode_qlen:=43,
-                                                 flush_qlen:=42}}}}} =
+    {error,{handler_not_added,{invalid_olp_levels,#{drop_mode_qlen:=43,
+                                                flush_qlen:=42}}}} =
         logger:add_handler(?MODULE,logger_disk_log_h,
                            #{config => #{drop_mode_qlen=>43,
                                          flush_qlen=>42}}),
@@ -445,7 +440,7 @@ config_fail(_Config) ->
                                      #{max_no_files=>2}),
     %% incorrect values of OP params
     {ok,#{config := HConfig}} = logger:get_handler_config(?MODULE),
-    {error,{invalid_config,logger_disk_log_h,{invalid_levels,_}}} =
+    {error,{invalid_olp_levels,_}} =
         logger:update_handler_config(?MODULE,config,
                                      HConfig#{sync_mode_qlen=>100,
                                               flush_qlen=>99}),
@@ -459,18 +454,7 @@ config_fail(cleanup,_Config) ->
 
 bad_input(_Config) ->
     {error,{badarg,{filesync,["BadType"]}}} =
-        logger_disk_log_h:filesync("BadType"),
-    {error,{badarg,{info,["BadType"]}}} = logger_disk_log_h:info("BadType"),
-    {error,{badarg,{reset,["BadType"]}}} = logger_disk_log_h:reset("BadType").
-
-info_and_reset(_Config) ->
-    ok = logger:add_handler(?MODULE,logger_disk_log_h,
-                            #{filter_default=>log,
-                              formatter=>{?MODULE,self()}}),
-    #{id := ?MODULE} = logger_disk_log_h:info(?MODULE),
-    ok = logger_disk_log_h:reset(?MODULE).
-info_and_reset(cleanup,_Config) ->
-    logger:remove_handler(?MODULE).
+        logger_disk_log_h:filesync("BadType").
 
 reconfig(Config) ->
     Dir = ?config(priv_dir,Config),
@@ -479,7 +463,7 @@ reconfig(Config) ->
                             #{filter_default=>log,
                               filters=>?DEFAULT_HANDLER_FILTERS([?MODULE]),
                               formatter=>{?MODULE,self()}}),
-    #{id := ?MODULE,
+    #{%id := ?MODULE,
       sync_mode_qlen := ?SYNC_MODE_QLEN,
       drop_mode_qlen := ?DROP_MODE_QLEN,
       flush_qlen := ?FLUSH_QLEN,
@@ -490,13 +474,14 @@ reconfig(Config) ->
       overload_kill_qlen := ?OVERLOAD_KILL_QLEN,
       overload_kill_mem_size := ?OVERLOAD_KILL_MEM_SIZE,
       overload_kill_restart_after := ?OVERLOAD_KILL_RESTART_AFTER,
-      filesync_repeat_interval := ?FILESYNC_REPEAT_INTERVAL,
-      handler_state :=
-          #{log_opts := #{type := ?DISK_LOG_TYPE,
-                          max_no_files := ?DISK_LOG_MAX_NO_FILES,
-                          max_no_bytes := ?DISK_LOG_MAX_NO_BYTES,
-                          file := DiskLogFile}}} =
-        logger_disk_log_h:info(?MODULE),
+      cb_state :=
+          #{handler_state :=
+                #{log_opts := #{type := ?DISK_LOG_TYPE,
+                                max_no_files := ?DISK_LOG_MAX_NO_FILES,
+                                max_no_bytes := ?DISK_LOG_MAX_NO_BYTES,
+                                file := DiskLogFile}},
+            filesync_repeat_interval := ?FILESYNC_REPEAT_INTERVAL}} =
+        logger_olp:info(h_proc_name()),
     {ok,#{config :=
               #{sync_mode_qlen := ?SYNC_MODE_QLEN,
                 drop_mode_qlen := ?DROP_MODE_QLEN,
@@ -527,7 +512,7 @@ reconfig(Config) ->
                          overload_kill_restart_after => infinity,
                          filesync_repeat_interval => no_repeat},
     ok = logger:set_handler_config(?MODULE, config, HConfig1),
-    #{id := ?MODULE,
+    #{%id := ?MODULE,
       sync_mode_qlen := 1,
       drop_mode_qlen := 2,
       flush_qlen := 3,
@@ -538,8 +523,8 @@ reconfig(Config) ->
       overload_kill_qlen := 100000,
       overload_kill_mem_size := 10000000,
       overload_kill_restart_after := infinity,
-      filesync_repeat_interval := no_repeat} =
-        logger_disk_log_h:info(?MODULE),
+      cb_state := #{filesync_repeat_interval := no_repeat}} =
+        logger_olp:info(h_proc_name()),
     {ok,#{config:=HConfig1}} = logger:get_handler_config(?MODULE),
 
     ok = logger:update_handler_config(?MODULE, config,
@@ -577,12 +562,13 @@ reconfig(Config) ->
                                     max_no_files => 1,
                                     max_no_bytes => 1024,
                                     file => File}}),
-    #{handler_state :=
-          #{log_opts := #{type := halt,
-                          max_no_files := 1,
-                          max_no_bytes := 1024,
-                          file := File}}} =
-        logger_disk_log_h:info(?MODULE),
+    #{cb_state :=
+          #{handler_state :=
+                #{log_opts := #{type := halt,
+                                max_no_files := 1,
+                                max_no_bytes := 1024,
+                                file := File}}}} =
+        logger_olp:info(h_proc_name()),
     {ok,#{config :=
               #{type := halt,
                 max_no_files := 1,
@@ -650,13 +636,8 @@ sync(Config) ->
     {ok,#{config := HConfig}} = logger:get_handler_config(?MODULE),
     HConfig1 = HConfig#{filesync_repeat_interval => no_repeat},
     ok = logger:update_handler_config(?MODULE, config, HConfig1),
-
     no_repeat = maps:get(filesync_repeat_interval,
-                         logger_disk_log_h:info(?MODULE)),
-    %% The following timer is to make sure the time from last log
-    %% ("first") to next ("second") is long enough, so the a flush is
-    %% triggered by the idle timeout between "fourth" and "fifth".
-    timer:sleep(?IDLE_DETECT_TIME_MSEC*2),
+                         maps:get(cb_state,logger_olp:info(h_proc_name()))),
 
     start_tracer([{logger_disk_log_h,disk_log_write,3},
                   {disk_log,sync,1}],
@@ -666,10 +647,10 @@ sync(Config) ->
                   {disk_log,sync}]),
 
     logger:notice("second", ?domain),
-    timer:sleep(?IDLE_DETECT_TIME_MSEC*2),
+    timer:sleep(?IDLE_DETECT_TIME*2),
     logger:notice("third", ?domain),
     %% wait for automatic disk_log_sync
-    check_tracer(?IDLE_DETECT_TIME_MSEC*2),
+    check_tracer(?IDLE_DETECT_TIME*2),
 
     try_read_file(Log, {ok,<<"first\nsecond\nthird\n">>}, 1000),
     
@@ -678,14 +659,15 @@ sync(Config) ->
     WaitT = 4500,
     OneSync = {logger_h_common,handle_cast,repeated_filesync},
     %% receive 1 repeated_filesync per sec
-    start_tracer([{logger_h_common,handle_cast,2}],
+    start_tracer([{{logger_h_common,handle_cast,2},
+                   [{[repeated_filesync,'_'],[],[{message,{caller}}]}]}],
                  [OneSync || _ <- lists:seq(1, trunc(WaitT/SyncInt))]),
 
     HConfig2 = HConfig#{filesync_repeat_interval => SyncInt},
     ok = logger:update_handler_config(?MODULE, config, HConfig2),
                       
     SyncInt = maps:get(filesync_repeat_interval,
-                       logger_disk_log_h:info(?MODULE)),
+                       maps:get(cb_state,logger_olp:info(h_proc_name()))),
     timer:sleep(WaitT),
     HConfig3 = HConfig#{filesync_repeat_interval => no_repeat},
     ok = logger:update_handler_config(?MODULE, config, HConfig3),
@@ -803,7 +785,7 @@ disk_log_full(cleanup, _Config) ->
     dbg:stop_clear(),
     logger:remove_handler(?MODULE).    
 
-disk_log_events(Config) ->
+disk_log_events(_Config) ->
     Node = node(),
     Log = ?MODULE,
     ok = logger:add_handler(?MODULE,
@@ -860,10 +842,12 @@ write_failure(Config) ->
     rpc:call(Node, ets, insert, [?TEST_HOOKS_TAB,{tester,self()}]),
     rpc:call(Node, ?MODULE, set_internal_log, [?MODULE,internal_log]),
     rpc:call(Node, ?MODULE, set_result, [disk_log_write,ok]),
-    HState = rpc:call(Node, logger_disk_log_h, info, [?STANDARD_HANDLER]),
-    ct:pal("LogOpts = ~p", [LogOpts = maps:get(log_opts,
-                                               maps:get(handler_state,HState))]),
-
+    HState = rpc:call(Node, logger_olp, info, [h_proc_name(?STANDARD_HANDLER)]),
+    LogOpts = maps:get(log_opts,
+                       maps:get(handler_state,
+                                maps:get(cb_state,HState))),
+    ct:pal("LogOpts = ~p", [LogOpts]),
+           
     %% ?check and ?check_no_log in this test only check for internal log events
     ok = log_on_remote_node(Node, "Logged1"),
     rpc:call(Node, logger_disk_log_h, filesync, [?STANDARD_HANDLER]),
@@ -914,15 +898,16 @@ sync_failure(Config) ->
     rpc:call(Node, ets, insert, [?TEST_HOOKS_TAB,{tester,self()}]),
     rpc:call(Node, ?MODULE, set_internal_log, [?MODULE,internal_log]),
     rpc:call(Node, ?MODULE, set_result, [disk_log_sync,ok]),
-    HState = rpc:call(Node, logger_disk_log_h, info, [?STANDARD_HANDLER]),
-    LogOpts = maps:get(log_opts, maps:get(handler_state,HState)),
+    HState = rpc:call(Node, logger_olp, info, [h_proc_name(?STANDARD_HANDLER)]),
+    LogOpts = maps:get(log_opts, maps:get(handler_state,
+                                          maps:get(cb_state,HState))),
     
     SyncInt = 500,
     ok = rpc:call(Node, logger, update_handler_config,
                   [?STANDARD_HANDLER, config,
                    #{filesync_repeat_interval => SyncInt}]),
-    Info = rpc:call(Node, logger_disk_log_h, info, [?STANDARD_HANDLER]),
-    SyncInt = maps:get(filesync_repeat_interval, Info),
+    Info = rpc:call(Node, logger_olp, info, [h_proc_name(?STANDARD_HANDLER)]),
+    SyncInt = maps:get(filesync_repeat_interval, maps:get(cb_state, Info)),
     
     ok = log_on_remote_node(Node, "Logged1"),
     ?check_no_log,
@@ -1198,7 +1183,7 @@ qlen_kill_new(Config) ->
     receive
         {'DOWN', MRef, _, _, Info} ->
            case Info of
-                {shutdown,{overloaded,?MODULE,QLen,Mem}} ->
+                {shutdown,{overloaded,QLen,Mem}} ->
                     ct:pal("Terminated with qlen = ~w, mem = ~w", [QLen,Mem]);
                 killed ->
                     ct:pal("Slow shutdown, handler process was killed!", [])
@@ -1208,7 +1193,7 @@ qlen_kill_new(Config) ->
             ok
     after
         5000 ->
-            Info = logger_disk_log_h:info(?MODULE),
+            Info = logger_olp:info(h_proc_name()),
             ct:pal("Handler state = ~p", [Info]),
             ct:fail("Handler not dead! It should not have survived this!")
     end.
@@ -1235,7 +1220,7 @@ mem_kill_new(Config) ->
     receive
         {'DOWN', MRef, _, _, Info} ->
             case Info of
-                {shutdown,{overloaded,?MODULE,QLen,Mem}} ->
+                {shutdown,{overloaded,QLen,Mem}} ->
                     ct:pal("Terminated with qlen = ~w, mem = ~w", [QLen,Mem]);
                 killed ->
                     ct:pal("Slow shutdown, handler process was killed!", [])
@@ -1245,7 +1230,7 @@ mem_kill_new(Config) ->
             ok
     after
         5000 ->
-            Info = logger_disk_log_h:info(?MODULE),
+            Info = logger_olp:info(h_proc_name()),
             ct:pal("Handler state = ~p", [Info]),
             ct:fail("Handler not dead! It should not have survived this!")
     end.
@@ -1271,7 +1256,7 @@ restart_after(Config) ->
             ok
     after
         5000 ->
-            Info1 = logger_std_h:info(?MODULE),
+            Info1 = logger_olp:info(h_proc_name()),
             ct:pal("Handler state = ~p", [Info1]),
             ct:fail("Handler not dead! It should not have survived this!")
     end,
@@ -1295,7 +1280,7 @@ restart_after(Config) ->
             ok
     after
         5000 ->
-            Info2 = logger_std_h:info(?MODULE),
+            Info2 = logger_olp:info(h_proc_name()),
             ct:pal("Handler state = ~p", [Info2]),
             ct:fail("Handler not dead! It should not have survived this!")
     end,
@@ -1316,11 +1301,15 @@ handler_requests_under_load(Config) ->
                                       flush_qlen => 2000,
                                       burst_limit_enable => false}},
     ok = logger:update_handler_config(?MODULE, NewHConfig),
-    Pid = spawn_link(fun() -> send_requests(?MODULE, 1, [{filesync,[]},
-                                                         {info,[]},
-                                                         {reset,[]},
-                                                         {change_config,[]}])
-                     end),
+    Pid = spawn_link(
+            fun() -> send_requests(1,[{logger_disk_log_h,filesync,[?MODULE],[]},
+                                      {logger_olp,info,[h_proc_name()],[]},
+                                      {logger_olp,reset,[h_proc_name()],[]},
+                                      {logger,update_handler_config,
+                                       [?MODULE, config,
+                                        #{overload_kill_enable => false}],
+                                       []}])
+            end),
     Procs = 100,
     Sent = Procs * send_burst({n,5000}, {spawn,Procs,10}, {chars,79}, notice),
     Pid ! {self(),finish},
@@ -1332,29 +1321,22 @@ handler_requests_under_load(Config) ->
                         [E || E <- Res,
                               is_tuple(E) andalso (element(1,E) == error)]
                 end,
-    Errors = [{Req,FindError(Res)} || {Req,Res} <- ReqResult],
-    NoOfReqs = lists:foldl(fun({_,Res}, N) -> N + length(Res) end, 0, ReqResult),
+    Errors = [{Func,FindError(Res)} || {_,Func,_,Res} <- ReqResult],
+    NoOfReqs = lists:foldl(fun({_,_,_,Res}, N) -> N + length(Res) end,
+                           0, ReqResult),
     ct:pal("~w requests made. Errors: ~n~p", [NoOfReqs,Errors]),
     ok = file_delete(Log).
 handler_requests_under_load(cleanup, _Config) ->
     ok = stop_handler(?MODULE).
 
-send_requests(HName, TO, Reqs = [{Req,Res}|Rs]) ->
+send_requests(TO, Reqs = [{Mod,Func,Args,Res}|Rs]) ->
     receive
         {From,finish} ->
             From ! {self(),Reqs}
     after
         TO ->
-            Result =
-                case Req of
-                    change_config ->
-                        logger:update_handler_config(HName, logger_disk_log_h,
-                                                     #{overload_kill_enable =>
-                                                           false});
-                    Func ->
-                        logger_disk_log_h:Func(HName)
-                end,
-            send_requests(HName, TO, Rs ++ [{Req,[Result|Res]}])
+            Result = apply(Mod,Func,Args),
+            send_requests(TO, Rs ++ [{Mod,Func,Args,[Result|Res]}])
     end.
 
 %%%-----------------------------------------------------------------
@@ -1472,15 +1454,6 @@ format(Msg,Tag) ->
     erlang:display(Error),
     exit(Error).
 
-remove(Handler, LogName) ->
-    logger_disk_log_h:remove(Handler, LogName),
-    HState = #{log_names := Logs} = logger_disk_log_h:info(),
-    false = maps:is_key(LogName, HState),
-    false = lists:member(LogName, Logs),
-    false = logger_config:exist(?LOGGER_TABLE, LogName),
-    {error,no_such_log} = disk_log:info(LogName),
-    ok.
-
 start_and_add(Name, Config, LogOpts) ->
     HConfig = maps:get(config, Config, #{}),
     HConfig1 = maps:merge(HConfig, LogOpts),
@@ -1607,7 +1580,9 @@ start_tracer(Trace,Expected) ->
     ok.
 
 tpl([{M,F,A}|Trace]) ->
-    {ok,Match} = dbg:tpl(M,F,A,c),
+    tpl([{{M,F,A},c}|Trace]);
+tpl([{{M,F,A},MS}|Trace]) ->
+    {ok,Match} = dbg:tpl(M,F,A,MS),
     case lists:keyfind(matched,1,Match) of
         {_,_,1} ->
             ok;
diff --git a/lib/kernel/test/logger_env_var_SUITE.erl b/lib/kernel/test/logger_env_var_SUITE.erl
index e8d1a313dc..9d2ad11be8 100644
--- a/lib/kernel/test/logger_env_var_SUITE.erl
+++ b/lib/kernel/test/logger_env_var_SUITE.erl
@@ -59,7 +59,8 @@ groups() ->
                  logger_undefined,
                  logger_many_handlers_default_first,
                  logger_many_handlers_default_last,
-                 logger_many_handlers_default_last_broken_filter
+                 logger_many_handlers_default_last_broken_filter,
+                 logger_proxy
                 ]},
      {bad,[],[bad_error_logger,
               bad_level,
@@ -541,6 +542,19 @@ logger_many_handlers(Config, Env, LogErr, LogInfo, NumProgress) ->
 
     ok.
 
+logger_proxy(Config) ->
+    %% assume current node runs with default settings
+    DefOpts = logger_olp:get_opts(logger_proxy),
+    {ok,_,Node} = setup(Config,
+                        [{logger,[{proxy,#{sync_mode_qlen=>0,
+                                           drop_mode_qlen=>2}}]}]),
+    Expected = DefOpts#{sync_mode_qlen:=0,
+                        drop_mode_qlen:=2},
+    Expected = rpc:call(Node,logger_olp,get_opts,[logger_proxy]),
+    Expected = rpc:call(Node,logger,get_proxy_config,[]),
+
+    ok.
+
 sasl_compatible_false(Config) ->
     Log = file(Config,?FUNCTION_NAME),
     {ok,_,Node} = setup(Config,
diff --git a/lib/kernel/test/logger_olp_SUITE.erl b/lib/kernel/test/logger_olp_SUITE.erl
new file mode 100644
index 0000000000..ea3eec89f5
--- /dev/null
+++ b/lib/kernel/test/logger_olp_SUITE.erl
@@ -0,0 +1,90 @@
+%%
+%% %CopyrightBegin%
+%%
+%% Copyright Ericsson AB 2018. All Rights Reserved.
+%%
+%% 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_olp_SUITE).
+
+-compile(export_all).
+
+-include_lib("kernel/src/logger_olp.hrl").
+
+suite() ->
+    [{timetrap,{seconds,30}}].
+
+init_per_suite(Config) ->
+    Config.
+
+end_per_suite(_Config) ->
+    ok.
+
+init_per_group(_Group, Config) ->
+    Config.
+
+end_per_group(_Group, _Config) ->
+    ok.
+
+init_per_testcase(_TestCase, Config) ->
+    Config.
+
+end_per_testcase(Case, Config) ->
+    try apply(?MODULE,Case,[cleanup,Config])
+    catch error:undef -> ok
+    end,
+    ok.
+
+groups() ->
+    [].
+
+all() -> 
+    [idle_timer].
+
+%%%-----------------------------------------------------------------
+%%% Test cases
+idle_timer(_Config) ->
+    {ok,_Pid,Olp} = logger_olp:start_link(?MODULE,?MODULE,self(),#{}),
+    [logger_olp:load(Olp,{msg,N}) || N<-lists:seq(1,3)],
+    timer:sleep(?IDLE_DETECT_TIME*2),
+    [{load,{msg,1}},
+     {load,{msg,2}},
+     {load,{msg,3}},
+     {notify,idle}] = test_server:messages_get(),
+    logger_olp:cast(Olp,hello),
+    timer:sleep(?IDLE_DETECT_TIME*2),
+    [{cast,hello}] = test_server:messages_get(),
+    ok.
+idle_timer(cleanup,_Config) ->
+    unlink(whereis(?MODULE)),
+    logger_olp:stop(?MODULE),
+    ok.
+
+%%%-----------------------------------------------------------------
+%%% Olp callbacks
+init(P) ->
+    {ok,P}.
+
+handle_load(M,P) ->
+    P ! {load,M},
+    P.
+
+handle_cast(M,P) ->
+    P ! {cast,M},
+    {noreply,P}.
+
+notify(N,P) ->
+    P ! {notify,N},
+    P.
diff --git a/lib/kernel/test/logger_proxy_SUITE.erl b/lib/kernel/test/logger_proxy_SUITE.erl
new file mode 100644
index 0000000000..777531e4ed
--- /dev/null
+++ b/lib/kernel/test/logger_proxy_SUITE.erl
@@ -0,0 +1,274 @@
+%%
+%% %CopyrightBegin%
+%%
+%% Copyright Ericsson AB 2018. All Rights Reserved.
+%%
+%% 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_proxy_SUITE).
+
+-compile(export_all).
+
+%% -include_lib("common_test/include/ct.hrl").
+%% -include_lib("kernel/include/logger.hrl").
+%% -include_lib("kernel/src/logger_internal.hrl").
+
+%% -define(str,"Log from "++atom_to_list(?FUNCTION_NAME)++
+%%             ":"++integer_to_list(?LINE)).
+%% -define(map_rep,#{function=>?FUNCTION_NAME, line=>?LINE}).
+%% -define(keyval_rep,[{function,?FUNCTION_NAME}, {line,?LINE}]).
+
+%% -define(MY_LOC(N),#{mfa=>{?MODULE,?FUNCTION_NAME,?FUNCTION_ARITY},
+%%                     file=>?FILE, line=>?LINE-N}).
+
+%% -define(TRY(X), my_try(fun() -> X end)).
+
+
+-define(HNAME,list_to_atom(lists:concat([?MODULE,"_",?FUNCTION_NAME]))).
+-define(LOC,#{mfa=>{?MODULE,?FUNCTION_NAME,?FUNCTION_ARITY},line=>?LINE}).
+-define(ENSURE_TIME,5000).
+
+suite() ->
+    [{timetrap,{seconds,30}},
+     {ct_hooks,[logger_test_lib]}].
+
+init_per_suite(Config) ->
+    Config.
+
+end_per_suite(_Config) ->
+    ok.
+
+init_per_group(_Group, Config) ->
+    Config.
+
+end_per_group(_Group, _Config) ->
+    ok.
+
+init_per_testcase(_TestCase, Config) ->
+    Config.
+
+end_per_testcase(Case, Config) ->
+    try apply(?MODULE,Case,[cleanup,Config])
+    catch error:undef -> ok
+    end,
+    ok.
+
+groups() ->
+    [].
+
+all() -> 
+    [basic,
+     emulator,
+     remote,
+     remote_emulator,
+     config,
+     restart_after,
+     terminate].
+
+%%%-----------------------------------------------------------------
+%%% Test cases
+basic(_Config) ->
+    ok = logger:add_handler(?HNAME,?MODULE,#{config=>self()}),
+    logger_proxy ! {log,notice,"Log from: ~p; ~p",[?FUNCTION_NAME,?LINE],L1=?LOC},
+    ok = ensure(L1),
+    logger_proxy ! {log,notice,[{test_case,?FUNCTION_NAME},{line,?LINE}],L2=?LOC},
+    ok = ensure(L2),
+    logger_proxy:log({remote,node(),{log,notice,
+                                     "Log from: ~p; ~p",
+                                     [?FUNCTION_NAME,?LINE],
+                                     L3=?LOC}}),
+    ok = ensure(L3),
+    logger_proxy:log({remote,node(),{log,notice,
+                                     [{test_case,?FUNCTION_NAME},
+                                      {line,?LINE}],
+                                     L4=?LOC}}),
+    ok = ensure(L4),
+    ok.
+basic(cleanup,_Config) ->
+    ok = logger:remove_handler(?HNAME).
+
+emulator(_Config) ->
+    ok = logger:add_handler(?HNAME,?MODULE,#{config=>self()}),
+    Pid = spawn(fun() -> erlang:error(some_reason) end),
+    ok = ensure(#{pid=>Pid}),
+    ok.
+emulator(cleanup,_Config) ->
+    ok = logger:remove_handler(?HNAME).
+
+remote(Config) ->
+    {ok,_,Node} = logger_test_lib:setup(Config,[{logger,[{proxy,#{}}]}]),
+    ok = logger:add_handler(?HNAME,?MODULE,#{config=>self()}),
+    L1 = ?LOC, spawn(Node,fun() -> logger:notice("Log from ~p; ~p",[?FUNCTION_NAME,?LINE],L1) end),
+    ok = ensure(L1),
+    L2 = ?LOC, spawn(Node,fun() -> logger:notice([{test_case,?FUNCTION_NAME},{line,?LINE}],L2) end),
+    ok = ensure(L2),
+    ok.
+remote(cleanup,_Config) ->
+    ok = logger:remove_handler(?HNAME).
+
+remote_emulator(Config) ->
+    {ok,_,Node} = logger_test_lib:setup(Config,[{logger,[{proxy,#{}}]}]),
+    ok = logger:add_handler(?HNAME,?MODULE,#{config=>self()}),
+    Pid = spawn(Node,fun() -> erlang:error(some_reason) end),
+    ok = ensure(#{pid=>Pid}),
+    ok.
+remote_emulator(cleanup,_Config) ->
+    ok = logger:remove_handler(?HNAME).
+
+config(_Config) ->
+    C1 = #{sync_mode_qlen:=SQ,
+           drop_mode_qlen:=DQ} = logger:get_proxy_config(),
+    C1 = logger_olp:get_opts(logger_proxy),
+
+    %% Update the existing config with these two values
+    SQ1 = SQ+1,
+    DQ1 = DQ+1,
+    ok = logger:update_proxy_config(#{sync_mode_qlen=>SQ1,
+                                      drop_mode_qlen=>DQ1}),
+    C2 = logger:get_proxy_config(), % reads from ets table
+    C2 = logger_olp:get_opts(logger_proxy), % ensure consistency with process opts
+    C2 = C1#{sync_mode_qlen:=SQ1,
+             drop_mode_qlen:=DQ1},
+
+    %% Update the existing again with only one value
+    SQ2 = SQ+2,
+    ok = logger:update_proxy_config(#{sync_mode_qlen=>SQ2}),
+    C3 = logger:get_proxy_config(),
+    C3 = logger_olp:get_opts(logger_proxy),
+    C3 = C2#{sync_mode_qlen:=SQ2},
+
+    %% Set the config, i.e. merge with defaults
+    ok = logger:set_proxy_config(#{sync_mode_qlen=>SQ1}),
+    C4 = logger:get_proxy_config(),
+    C4 = logger_olp:get_opts(logger_proxy),
+    C4 = C1#{sync_mode_qlen:=SQ1},
+
+    %% Reset to default
+    ok = logger:set_proxy_config(#{}),
+    C5 = logger:get_proxy_config(),
+    C5 = logger_olp:get_opts(logger_proxy),
+    C5 = logger_proxy:get_default_config(),
+
+    %% Errors
+    {error,{invalid_olp_config,_}} =
+        logger:set_proxy_config(#{faulty_key=>1}),
+    {error,{invalid_olp_config,_}} =
+        logger:set_proxy_config(#{sync_mode_qlen=>infinity}),
+    {error,{invalid_config,[]}} = logger:set_proxy_config([]),
+
+    {error,{invalid_olp_config,_}} =
+        logger:update_proxy_config(#{faulty_key=>1}),
+    {error,{invalid_olp_config,_}} =
+        logger:update_proxy_config(#{sync_mode_qlen=>infinity}),
+    {error,{invalid_config,[]}} = logger:update_proxy_config([]),
+
+    C5 = logger:get_proxy_config(),
+    C5 = logger_olp:get_opts(logger_proxy),
+
+    ok.
+config(cleanup,_Config) ->
+    _ = logger:set_logger_proxy(logger_proxy:get_default_config()),
+    ok.
+
+restart_after(_Config) ->
+    Restart = 3000,
+    ok = logger:update_proxy_config(#{overload_kill_enable => true,
+                                      overload_kill_qlen => 10,
+                                      overload_kill_restart_after => Restart}),
+    Proxy = whereis(logger_proxy),
+    Proxy = erlang:system_info(system_logger),
+    ProxyConfig = logger:get_proxy_config(),
+    ProxyConfig = logger_olp:get_opts(logger_proxy),
+
+    Ref = erlang:monitor(process,Proxy),
+    spawn(fun() ->
+                  [logger_proxy ! {log,debug,
+                                   [{test_case,?FUNCTION_NAME},
+                                    {line,?LINE}],
+                                   ?LOC} || _ <- lists:seq(1,100)]
+          end),
+    receive
+        {'DOWN',Ref,_,_,_Reason} ->
+            undefined = erlang:system_info(system_logger),
+            timer:sleep(Restart),
+            poll_restarted(10)
+    after 5000 ->
+            ct:fail(proxy_not_terminated)
+    end,
+
+    Proxy1 = whereis(logger_proxy),
+    Proxy1 = erlang:system_info(system_logger),
+    ProxyConfig = logger:get_proxy_config(),
+    ProxyConfig = logger_olp:get_opts(logger_proxy),
+
+    ok.
+restart_after(cleanup,_Config) ->
+    _ = logger:set_logger_proxy(logger_proxy:get_default_config()),
+    ok.
+
+%% Test that system_logger flag is set to logger process if
+%% logger_proxy terminates for other reason than overloaded.
+terminate(_Config) ->
+    Logger = whereis(logger),
+    Proxy = whereis(logger_proxy),
+    Proxy = erlang:system_info(system_logger),
+    ProxyConfig = logger:get_proxy_config(),
+    ProxyConfig = logger_olp:get_opts(logger_proxy),
+
+    Ref = erlang:monitor(process,Proxy),
+    ok = logger_olp:stop(Proxy),
+    receive
+        {'DOWN',Ref,_,_,_Reason} ->
+            Logger = erlang:system_info(system_logger),
+            logger_proxy:restart(),
+            poll_restarted(10)
+    after 5000 ->
+            ct:fail(proxy_not_terminated)
+    end,
+
+    Proxy1 = whereis(logger_proxy),
+    Proxy1 = erlang:system_info(system_logger),
+    ProxyConfig = logger:get_proxy_config(),
+    ProxyConfig = logger_olp:get_opts(logger_proxy),
+
+    ok.
+
+%%%-----------------------------------------------------------------
+%%% Internal functions
+
+poll_restarted(0) ->
+    ct:fail(proxy_not_restarted);
+poll_restarted(N) ->
+    timer:sleep(1000),
+    case whereis(logger_proxy) of
+        undefined ->
+            poll_restarted(N-1);
+        _Pid ->
+            ok
+    end.
+
+%% Logger handler callback
+log(#{meta:=Meta},#{config:=Pid}) ->
+    Pid ! {logged,Meta}.
+
+%% Check that the log from the logger callback function log/2 is received
+ensure(Match) ->
+    receive {logged,Meta} ->
+            case maps:with(maps:keys(Match),Meta) of
+                Match -> ok;
+                _NoMatch -> {error,Match,Meta,test_server:messages_get()}
+            end
+    after ?ENSURE_TIME -> {error,Match,test_server:messages_get()}
+    end.
diff --git a/lib/kernel/test/logger_std_h_SUITE.erl b/lib/kernel/test/logger_std_h_SUITE.erl
index eb17a6d857..484d914ec3 100644
--- a/lib/kernel/test/logger_std_h_SUITE.erl
+++ b/lib/kernel/test/logger_std_h_SUITE.erl
@@ -25,10 +25,15 @@
 -include_lib("kernel/include/logger.hrl").
 -include_lib("kernel/src/logger_internal.hrl").
 -include_lib("kernel/src/logger_h_common.hrl").
+-include_lib("kernel/src/logger_olp.hrl").
 -include_lib("stdlib/include/ms_transform.hrl").
 -include_lib("kernel/include/file.hrl").
 
--define(check_no_log, [] = test_server:messages_get()).
+-define(check_no_log,
+        begin
+            timer:sleep(?IDLE_DETECT_TIME*2),
+            [] = test_server:messages_get()
+        end).
 -define(check(Expected),
         receive
             {log,Expected} ->
@@ -115,7 +120,6 @@ all() ->
      crash_std_h_to_file,
      crash_std_h_to_disk_log,
      bad_input,
-     info_and_reset,
      reconfig,
      file_opts,
      sync,
@@ -209,9 +213,9 @@ default_formatter(_Config) ->
 filter_config(_Config) ->
     ok = logger:add_handler(?MODULE,logger_std_h,#{}),
     {ok,#{config:=HConfig}=Config} = logger:get_handler_config(?MODULE),
-    HConfig = maps:without([handler_pid,mode_tab],HConfig),
+    HConfig = maps:without([olp],HConfig),
 
-    FakeFullHConfig = HConfig#{handler_pid=>self(),mode_tab=>erlang:make_ref()},
+    FakeFullHConfig = HConfig#{olp=>{regname,self(),erlang:make_ref()}},
     #{config:=HConfig} =
         logger_std_h:filter_config(Config#{config=>FakeFullHConfig}),
     ok.
@@ -246,13 +250,13 @@ errors(Config) ->
         _ ->
             NoDir = lists:concat(["/",?MODULE,"_dir"]),
             {error,
-             {handler_not_added,{{open_failed,NoDir,eacces},_}}} =
+             {handler_not_added,{open_failed,NoDir,eacces}}} =
                 logger:add_handler(myh2,logger_std_h,
                                    #{config=>#{type=>{file,NoDir}}})
     end,
 
     {error,
-     {handler_not_added,{{open_failed,Log,_},_}}} =
+     {handler_not_added,{open_failed,Log,_}}} =
         logger:add_handler(myh3,logger_std_h,
                            #{config=>#{type=>{file,Log,[bad_file_opt]}}}),
 
@@ -320,19 +324,16 @@ config_fail(_Config) ->
                            #{config => #{restart_type => bad},
                              filter_default=>log,
                              formatter=>{?MODULE,self()}}),
-    {error,{handler_not_added,{invalid_config,logger_std_h,
-                               {invalid_levels,#{drop_mode_qlen:=1}}}}} =
+    {error,{handler_not_added,{invalid_olp_levels,#{drop_mode_qlen:=1}}}} =
         logger:add_handler(?MODULE,logger_std_h,
                            #{config => #{drop_mode_qlen=>1}}),
-    {error,{handler_not_added,{invalid_config,logger_std_h,
-                               {invalid_levels,#{sync_mode_qlen:=43,
-                                                 drop_mode_qlen:=42}}}}} =
+    {error,{handler_not_added,{invalid_olp_levels,#{sync_mode_qlen:=43,
+                                                    drop_mode_qlen:=42}}}} =
         logger:add_handler(?MODULE,logger_std_h,
                            #{config => #{sync_mode_qlen=>43,
                                          drop_mode_qlen=>42}}),
-    {error,{handler_not_added,{invalid_config,logger_std_h,
-                               {invalid_levels,#{drop_mode_qlen:=43,
-                                                 flush_qlen:=42}}}}} =
+    {error,{handler_not_added,{invalid_olp_levels,#{drop_mode_qlen:=43,
+                                                    flush_qlen:=42}}}} =
         logger:add_handler(?MODULE,logger_std_h,
                            #{config => #{drop_mode_qlen=>43,
                                          flush_qlen=>42}}),
@@ -344,7 +345,7 @@ config_fail(_Config) ->
         logger:set_handler_config(?MODULE,config,
                                   #{type=>{file,"file"}}),
 
-    {error,{invalid_config,logger_std_h,{invalid_levels,_}}} =
+    {error,{invalid_olp_levels,_}} =
         logger:set_handler_config(?MODULE,config,
                                   #{sync_mode_qlen=>100,
                                     flush_qlen=>99}),
@@ -355,9 +356,7 @@ config_fail(_Config) ->
     %% Read-only fields may (accidentially) be included in the change,
     %% but it won't take effect
     {ok,C} = logger:get_handler_config(?MODULE),
-    ok = logger:set_handler_config(?MODULE,config,
-                                   #{handler_pid=>self(),
-                                     mode_tab=>erlang:make_ref()}),
+    ok = logger:set_handler_config(?MODULE,config,#{olp=>dummyvalue}),
     {ok,C} = logger:get_handler_config(?MODULE),
 
     ok.
@@ -425,10 +424,13 @@ crash_std_h(Config,Func,Var,Type,Log) ->
 %% logger would send the log event to the logger process here instead
 %% of logging it itself.
 log_on_remote_node(Node,Msg) ->
+    Pid = self(),
     _ = spawn_link(Node,
                    fun() -> erlang:group_leader(whereis(user),self()),
-                            logger:notice(Msg)
+                            logger:notice(Msg),
+                            Pid ! done
                    end),
+    receive done -> ok end,
     ok.
 
 
@@ -456,14 +458,7 @@ sync_and_read(Node,file,Log) ->
     end.
 
 bad_input(_Config) ->
-    {error,{badarg,{filesync,["BadType"]}}} = logger_std_h:filesync("BadType"),
-    {error,{badarg,{info,["BadType"]}}} = logger_std_h:info("BadType"),
-    {error,{badarg,{reset,["BadType"]}}} = logger_std_h:reset("BadType").
-
-
-info_and_reset(_Config) ->
-    #{id := ?STANDARD_HANDLER} = logger_std_h:info(?STANDARD_HANDLER),
-    ok = logger_std_h:reset(?STANDARD_HANDLER).
+    {error,{badarg,{filesync,["BadType"]}}} = logger_std_h:filesync("BadType").
 
 reconfig(Config) ->
     Dir = ?config(priv_dir,Config),
@@ -473,9 +468,10 @@ reconfig(Config) ->
                               filter_default=>log,
                               filters=>?DEFAULT_HANDLER_FILTERS([?MODULE]),
                               formatter=>{?MODULE,self()}}),
-    #{id := ?MODULE,
-      handler_state := #{type := standard_io,
-                         file_ctrl_pid := FileCtrlPid},
+    #{%id := ?MODULE,
+      cb_state:=#{handler_state := #{type := standard_io,
+                                     file_ctrl_pid := FileCtrlPid},
+                  filesync_repeat_interval := no_repeat},
       sync_mode_qlen := ?SYNC_MODE_QLEN,
       drop_mode_qlen := ?DROP_MODE_QLEN,
       flush_qlen := ?FLUSH_QLEN,
@@ -485,9 +481,8 @@ reconfig(Config) ->
       overload_kill_enable := ?OVERLOAD_KILL_ENABLE,
       overload_kill_qlen := ?OVERLOAD_KILL_QLEN,
       overload_kill_mem_size := ?OVERLOAD_KILL_MEM_SIZE,
-      overload_kill_restart_after := ?OVERLOAD_KILL_RESTART_AFTER,
-      filesync_repeat_interval := no_repeat} = DefaultInfo =
-        logger_std_h:info(?MODULE),
+      overload_kill_restart_after := ?OVERLOAD_KILL_RESTART_AFTER} =
+        logger_olp:info(h_proc_name()),
 
     {ok,
      #{config:=
@@ -518,9 +513,10 @@ reconfig(Config) ->
                                      overload_kill_mem_size => 10000000,
                                      overload_kill_restart_after => infinity,
                                      filesync_repeat_interval => 5000}),
-    #{id := ?MODULE,
-      handler_state := #{type := standard_io,
-                         file_ctrl_pid := FileCtrlPid},
+    #{%id := ?MODULE,
+      cb_state := #{handler_state := #{type := standard_io,
+                                       file_ctrl_pid := FileCtrlPid},
+                    filesync_repeat_interval := no_repeat},
       sync_mode_qlen := 1,
       drop_mode_qlen := 2,
       flush_qlen := 3,
@@ -530,8 +526,7 @@ reconfig(Config) ->
       overload_kill_enable := true,
       overload_kill_qlen := 100000,
       overload_kill_mem_size := 10000000,
-      overload_kill_restart_after := infinity,
-      filesync_repeat_interval := no_repeat} = Info = logger_std_h:info(?MODULE),
+      overload_kill_restart_after := infinity} = logger_olp:info(h_proc_name()),
 
     {ok,#{config :=
               #{type := standard_io,
@@ -613,7 +608,7 @@ file_opts(Config) ->
     Log = filename:join(Dir, lists:concat([?FUNCTION_NAME,".log"])),
     BadFileOpts = [raw],
     BadType = {file,Log,BadFileOpts},
-    {error,{handler_not_added,{{open_failed,Log,enoent},_}}} =
+    {error,{handler_not_added,{open_failed,Log,enoent}}} =
         logger:add_handler(?MODULE, logger_std_h,
                            #{config => #{type => BadType}}),
 
@@ -626,7 +621,9 @@ file_opts(Config) ->
                               filters=>?DEFAULT_HANDLER_FILTERS([?MODULE]),
                               formatter=>{?MODULE,self()}}),
 
-    #{handler_state := #{type := OkType}} = logger_std_h:info(?MODULE),
+    #{cb_state := #{handler_state := #{type := OkType}}} =
+        logger_olp:info(h_proc_name()),
+    {ok,#{config := #{type := OkType}}} = logger:get_handler_config(?MODULE),
     logger:notice(M1=?msg,?domain),
     ?check(M1),
     B1 = ?bin(M1),
@@ -675,11 +672,8 @@ sync(Config) ->
     %% a filesync is still performed when handler goes idle
     ok = logger:update_handler_config(?MODULE, config,
                                       #{filesync_repeat_interval => no_repeat}),
-    no_repeat = maps:get(filesync_repeat_interval, logger_std_h:info(?MODULE)),
-    %% The following timer is to make sure the time from last log
-    %% ("second") to next ("third") is long enough, so the a flush is
-    %% triggered by the idle timeout between "thrid" and "fourth".
-    timer:sleep(?IDLE_DETECT_TIME_MSEC*2),
+    no_repeat = maps:get(filesync_repeat_interval,
+                         maps:get(cb_state, logger_olp:info(h_proc_name()))),
     start_tracer([{logger_std_h, write_to_dev, 5},
                   {file, datasync, 1}],
                  [{logger_std_h, write_to_dev, <<"third\n">>},
@@ -688,22 +682,24 @@ sync(Config) ->
                   {file,datasync}]),
     logger:notice("third", ?domain),
     %% wait for automatic filesync
-    timer:sleep(?IDLE_DETECT_TIME_MSEC*2),
+    timer:sleep(?IDLE_DETECT_TIME*2),
     logger:notice("fourth", ?domain),
     %% wait for automatic filesync
-    check_tracer(?IDLE_DETECT_TIME_MSEC*2),
+    check_tracer(?IDLE_DETECT_TIME*2),
 
     %% switch repeated filesync on and verify that the looping works
     SyncInt = 1000,
     WaitT = 4500,
     OneSync = {logger_h_common,handle_cast,repeated_filesync},
     %% receive 1 repeated_filesync per sec
-    start_tracer([{logger_h_common,handle_cast,2}],
+    start_tracer([{{logger_h_common,handle_cast,2},
+                   [{[repeated_filesync,'_'],[],[]}]}],
                  [OneSync || _ <- lists:seq(1, trunc(WaitT/SyncInt))]),
 
     ok = logger:update_handler_config(?MODULE, config,
                                       #{filesync_repeat_interval => SyncInt}),
-    SyncInt = maps:get(filesync_repeat_interval, logger_std_h:info(?MODULE)),
+    SyncInt = maps:get(filesync_repeat_interval,
+                       maps:get(cb_state,logger_olp:info(h_proc_name()))),
     timer:sleep(WaitT),
     ok = logger:update_handler_config(?MODULE, config,
                                       #{filesync_repeat_interval => no_repeat}),
@@ -764,8 +760,6 @@ sync_failure(Config) ->
     ok = rpc:call(Node, logger, update_handler_config,
                   [?STANDARD_HANDLER, config,
                    #{filesync_repeat_interval => SyncInt}]),
-    Info = rpc:call(Node, logger_std_h, info, [?STANDARD_HANDLER]),
-    SyncInt = maps:get(filesync_repeat_interval, Info),
     
     ok = log_on_remote_node(Node, "Logged1"),
     ?check_no_log,
@@ -1095,7 +1089,7 @@ qlen_kill_new(Config) ->
     receive
         {'DOWN', MRef, _, _, Info} ->
            case Info of
-                {shutdown,{overloaded,?MODULE,QLen,Mem}} ->
+                {shutdown,{overloaded,QLen,Mem}} ->
                     ct:pal("Terminated with qlen = ~w, mem = ~w", [QLen,Mem]);
                 killed ->
                     ct:pal("Slow shutdown, handler process was killed!", [])
@@ -1105,7 +1099,7 @@ qlen_kill_new(Config) ->
             ok
     after
         5000 ->
-            Info = logger_std_h:info(?MODULE),
+            Info = logger_olp:info(h_proc_name()),
             ct:pal("Handler state = ~p", [Info]),
             ct:fail("Handler not dead! It should not have survived this!")
     end.
@@ -1146,7 +1140,7 @@ mem_kill_new(Config) ->
     receive
         {'DOWN', MRef, _, _, Info} ->
             case Info of
-                {shutdown,{overloaded,?MODULE,QLen,Mem}} ->
+                {shutdown,{overloaded,QLen,Mem}} ->
                     ct:pal("Terminated with qlen = ~w, mem = ~w", [QLen,Mem]);
                 killed ->
                     ct:pal("Slow shutdown, handler process was killed!", [])
@@ -1156,7 +1150,7 @@ mem_kill_new(Config) ->
             ok
     after
         5000 ->
-            Info = logger_std_h:info(?MODULE),
+            Info = logger_olp:info(h_proc_name()),
             ct:pal("Handler state = ~p", [Info]),
             ct:fail("Handler not dead! It should not have survived this!")
     end.
@@ -1187,7 +1181,7 @@ restart_after(Config) ->
             ok
     after
         5000 ->
-            Info1 = logger_std_h:info(?MODULE),
+            Info1 = logger_olp:info(h_proc_name()),
             ct:pal("Handler state = ~p", [Info1]),
             ct:fail("Handler not dead! It should not have survived this!")
     end,
@@ -1212,7 +1206,7 @@ restart_after(Config) ->
             ok
     after
         5000 ->
-            Info2 = logger_std_h:info(?MODULE),
+            Info2 = logger_olp:info(h_proc_name()),
             ct:pal("Handler state = ~p", [Info2]),
             ct:fail("Handler not dead! It should not have survived this!")
     end,
@@ -1234,11 +1228,15 @@ handler_requests_under_load(Config) ->
                                        flush_qlen => 2000,
                                        burst_limit_enable => false}},
     ok = logger:update_handler_config(?MODULE, NewHConfig),
-    Pid = spawn_link(fun() -> send_requests(?MODULE, 1, [{filesync,[]},
-                                                         {info,[]},
-                                                         {reset,[]},
-                                                         {change_config,[]}])
-                     end),
+    Pid = spawn_link(
+            fun() -> send_requests(1,[{logger_std_h,filesync,[?MODULE],[]},
+                                      {logger_olp,info,[h_proc_name()],[]},
+                                      {logger_olp,reset,[h_proc_name()],[]},
+                                      {logger,update_handler_config,
+                                       [?MODULE, config,
+                                        #{overload_kill_enable => false}],
+                                       []}])
+            end),
     Sent = send_burst({t,10000}, seq, {chars,79}, notice),
     Pid ! {self(),finish},
     ReqResult = receive {Pid,Result} -> Result end,
@@ -1249,8 +1247,9 @@ handler_requests_under_load(Config) ->
                         [E || E <- Res,
                               is_tuple(E) andalso (element(1,E) == error)]
                 end,
-    Errors = [{Req,FindError(Res)} || {Req,Res} <- ReqResult],
-    NoOfReqs = lists:foldl(fun({_,Res}, N) -> N + length(Res) end, 0, ReqResult),
+    Errors = [{Func,FindError(Res)} || {_,Func,_,Res} <- ReqResult],
+    NoOfReqs = lists:foldl(fun({_,_,_,Res}, N) -> N + length(Res) end,
+                           0, ReqResult),
     ct:pal("~w requests made. Errors: ~n~p", [NoOfReqs,Errors]),
     ok = file_delete(Log).
 handler_requests_under_load(cleanup, _Config) ->
@@ -1272,22 +1271,14 @@ recreate_deleted_log(cleanup, _Config) ->
 
 %%%-----------------------------------------------------------------
 %%%
-send_requests(HName, TO, Reqs = [{Req,Res}|Rs]) ->
+send_requests(TO, Reqs = [{Mod,Func,Args,Res}|Rs]) ->
     receive
         {From,finish} ->
             From ! {self(),Reqs}
     after
         TO ->
-            Result =
-                case Req of
-                    change_config ->
-                        logger:update_handler_config(HName, config,
-                                                     #{overload_kill_enable =>
-                                                           false});
-                    Func ->
-                        logger_std_h:Func(HName)
-                end,
-            send_requests(HName, TO, Rs ++ [{Req,[Result|Res]}])
+            Result = apply(Mod,Func,Args),
+            send_requests(TO, Rs ++ [{Mod,Func,Args,[Result|Res]}])
     end.
             
 
@@ -1624,7 +1615,8 @@ start_tracer(Trace,Expected) ->
     Pid = self(),
     FileCtrlPid = maps:get(file_ctrl_pid,
                            maps:get(handler_state,
-                                    logger_std_h:info(?MODULE))),
+                                    maps:get(cb_state,
+                                             logger_olp:info(h_proc_name())))),
     dbg:tracer(process,{fun tracer/2,{Pid,Expected}}),
     dbg:p(whereis(h_proc_name()),[c]),
     dbg:p(FileCtrlPid,[c]),
@@ -1632,7 +1624,9 @@ start_tracer(Trace,Expected) ->
     ok.
 
 tpl([{M,F,A}|Trace]) ->
-    {ok,Match} = dbg:tpl(M,F,A,[]),
+    tpl([{{M,F,A},[]}|Trace]);
+tpl([{{M,F,A},MS}|Trace]) ->
+    {ok,Match} = dbg:tpl(M,F,A,MS),
     case lists:keyfind(matched,1,Match) of
         {_,_,1} ->
             ok;
diff --git a/lib/kernel/test/logger_stress_SUITE.erl b/lib/kernel/test/logger_stress_SUITE.erl
new file mode 100644
index 0000000000..4072e8c86a
--- /dev/null
+++ b/lib/kernel/test/logger_stress_SUITE.erl
@@ -0,0 +1,456 @@
+%%
+%% %CopyrightBegin%
+%%
+%% Copyright Ericsson AB 2018. All Rights Reserved.
+%%
+%% 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_stress_SUITE).
+
+-compile(export_all).
+
+-include_lib("common_test/include/ct_event.hrl").
+-include_lib("kernel/include/logger.hrl").
+-include_lib("kernel/src/logger_h_common.hrl").
+
+-ifdef(SAVE_STATS).
+  -define(COLLECT_STATS(_All_,_Procs_),
+          ct:pal("~p",[stats(_All_,_Procs_)])).
+-else.
+  -define(COLLECT_STATS(_All_,_Procs__), ok).
+-endif.
+
+-define(TEST_DURATION,120). % seconds
+
+suite() ->
+    [{timetrap,{minutes,3}},
+     {ct_hooks,[logger_test_lib]}].
+
+init_per_suite(Config) ->
+    Config.
+
+end_per_suite(_Config) ->
+    ok.
+
+init_per_group(_Group, Config) ->
+    Config.
+
+end_per_group(_Group, _Config) ->
+    ok.
+
+init_per_testcase(_TestCase, Config) ->
+    Config.
+
+end_per_testcase(Case, Config) ->
+    try apply(?MODULE,Case,[cleanup,Config])
+    catch error:undef -> ok
+    end,
+    ok.
+
+groups() ->
+    [].
+
+all() -> 
+    [allow_events,
+     reject_events,
+     std_handler,
+     disk_log_handler,
+     emulator_events,
+     remote_events,
+     remote_to_disk_log,
+     remote_emulator_events,
+     remote_emulator_to_disk_log].
+
+%%%-----------------------------------------------------------------
+%%% Test cases
+%%%-----------------------------------------------------------------
+%% Time from log macro call to handler callback
+allow_events(Config) ->
+    {ok,_,Node} =
+        logger_test_lib:setup(Config,
+                              [{logger,
+                                [{handler,default,?MODULE,#{}}]},
+                               {logger_level,notice}]),
+    N = 100000,
+    {T,_} = timer:tc(fun() -> rpc:call(Node,?MODULE,nlogs,[N]) end),
+    IOPS = N * 1000/T, % log events allowed per millisecond
+    ct_event:notify(#event{name = benchmark_data,
+                           data = [{value,IOPS}]}),
+    {comment,io_lib:format("~.2f accepted events pr millisecond",
+                           [IOPS])}.
+
+%% Time from log macro call to reject (log level)
+reject_events(Config) ->
+    {ok,_,Node} =
+        logger_test_lib:setup(Config,
+                              [{logger,
+                                [{handler,default,?MODULE,#{}}]},
+                               {logger_level,error}]),
+    N = 1000000,
+    {T,_} = timer:tc(fun() -> rpc:call(Node,?MODULE,nlogs,[N]) end),
+    IOPS = N * 1000/T, % log events rejected per millisecond
+    ct_event:notify(#event{name = benchmark_data,
+                           data = [{value,IOPS}]}),
+    {comment,io_lib:format("~.2f rejected events pr millisecond",
+                           [IOPS])}.
+
+%% Cascading failure that produce gen_server and proc_lib reports -
+%% how many of the produced log events are actually written to a log
+%% with logger_std_h file handler.
+std_handler(Config) ->
+    {ok,_,Node} =
+        logger_test_lib:setup(Config,
+                              [{logger,
+                                [{handler,default,logger_std_h,
+                                  #{config=>#{type=>{file,"default.log"}}}}]}]),
+
+    cascade({Node,{logger_backend,log_allowed,2},[]},
+            {Node,{logger_std_h,write,4},[{default,logger_std_h_default}]},
+            fun otp_cascading/0).
+std_handler(cleanup,_Config) ->
+    _ = file:delete("default.log"),
+    ok.
+
+%% Cascading failure that produce gen_server and proc_lib reports -
+%% how many of the produced log events are actually written to a log
+%% with logger_disk_log_h wrap file handler.
+disk_log_handler(Config) ->
+    {ok,_,Node} =
+        logger_test_lib:setup(Config,
+                              [{logger,
+                                [{handler,default,logger_disk_log_h,#{}}]}]),
+    cascade({Node,{logger_backend,log_allowed,2},[]},
+            {Node,{logger_disk_log_h,write,4},
+             [{default,logger_disk_log_h_default}]},
+            fun otp_cascading/0).
+disk_log_handler(cleanup,_Config) ->
+    Files = filelib:wildcard("default.log.*"),
+    [_ = file:delete(F) || F <- Files],
+    ok.
+
+%% Cascading failure that produce log events from the emulator - how
+%% many of the produced log events pass through the proxy.
+emulator_events(Config) ->
+    {ok,_,Node} =
+        logger_test_lib:setup(Config,
+                              [{logger,
+                                [{handler,default,?MODULE,#{}}]}]),
+    cascade({Node,{?MODULE,producer,0},[]},
+            {Node,{?MODULE,log,2},[{proxy,logger_proxy}]},
+            fun em_cascading/0).
+
+%% Cascading failure that produce gen_server and proc_lib reports on
+%% remote node - how many of the produced log events pass through the
+%% proxy.
+remote_events(Config) ->
+    {ok,_,Node1} =
+        logger_test_lib:setup([{postfix,1}|Config],
+                              [{logger,
+                                [{handler,default,?MODULE,#{}}]}]),
+    {ok,_,Node2} =
+        logger_test_lib:setup([{postfix,2}|Config],[]),
+    cascade({Node2,{logger_backend,log_allowed,2},[{remote_proxy,logger_proxy}]},
+            {Node1,{?MODULE,log,2},[{local_proxy,logger_proxy}]},
+            fun otp_cascading/0).
+
+%% Cascading failure that produce gen_server and proc_lib reports on
+%% remote node - how many of the produced log events are actually
+%% written to a log with logger_disk_log_h wrap file handler.
+remote_to_disk_log(Config) ->
+    {ok,_,Node1} =
+        logger_test_lib:setup([{postfix,1}|Config],
+                              [{logger,
+                                [{handler,default,logger_disk_log_h,#{}}]}]),
+    {ok,_,Node2} =
+        logger_test_lib:setup([{postfix,2}|Config],[]),
+    cascade({Node2,{logger_backend,log_allowed,2},[{remote_proxy,logger_proxy}]},
+            {Node1,{logger_disk_log_h,write,4},
+             [{local_proxy,logger_proxy},
+              {local_default,logger_disk_log_h_default}]},
+            fun otp_cascading/0).
+remote_to_disk_log(cleanup,_Config) ->
+    Files = filelib:wildcard("default.log.*"),
+    [_ = file:delete(F) || F <- Files],
+    ok.
+
+%% Cascading failure that produce log events from the emulator on
+%% remote node - how many of the produced log events pass through the
+%% proxy.
+remote_emulator_events(Config) ->
+    {ok,_,Node1} =
+        logger_test_lib:setup([{postfix,1}|Config],
+                              [{logger,
+                                [{handler,default,?MODULE,#{}}]}]),
+    {ok,_,Node2} =
+        logger_test_lib:setup([{postfix,2}|Config],[]),
+    cascade({Node2,{?MODULE,producer,0},[{remote_proxy,logger_proxy}]},
+            {Node1,{?MODULE,log,2},[{local_proxy,logger_proxy}]},
+            fun em_cascading/0).
+
+%% Cascading failure that produce log events from the emulator on
+%% remote node - how many of the produced log events are actually
+%% written to a log with logger_disk_log_h wrap file handler.
+remote_emulator_to_disk_log(Config) ->
+    {ok,_,Node1} =
+        logger_test_lib:setup([{postfix,1}|Config],
+                              [{logger,
+                                [{handler,default,logger_disk_log_h,#{}}]}]),
+    {ok,_,Node2} =
+        logger_test_lib:setup([{postfix,2}|Config],[]),
+    cascade({Node2,{?MODULE,producer,0},[{remote_proxy,logger_proxy}]},
+            {Node1,{logger_disk_log_h,write,4},
+             [{local_proxy,logger_proxy},
+              {local_default,logger_disk_log_h_default}]},
+            fun em_cascading/0).
+remote_emulator_to_disk_log(cleanup,_Config) ->
+    Files = filelib:wildcard("default.log.*"),
+    [_ = file:delete(F) || F <- Files],
+    ok.
+
+%%%-----------------------------------------------------------------
+%%% Internal functions
+nlogs(N) ->
+    group_leader(whereis(user),self()),
+    Str = "\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+        "[\\]^_`abcdefghijklmnopqr",
+    [?LOG_NOTICE(Str) || _ <- lists:seq(1,N)],
+    ok.
+
+%% cascade(ProducerInfo,ConsumerInfo,TestFun)
+cascade({PNode,PMFA,_PStatProcs},{CNode,CMFA,_CStatProcs},TestFun) ->
+    Tab  = ets:new(counter,[set,public]),
+    ets:insert(Tab,{producer,0}),
+    ets:insert(Tab,{consumer,0}),
+    dbg:tracer(process,{fun tracer/2,{Tab,PNode,CNode}}),
+    dbg:n(PNode),
+    dbg:n(CNode),
+    dbg:cn(node()),
+    dbg:p(all,[call,arity]),
+    dbg:tpl(PMFA,[]),
+    dbg:tpl(CMFA,[]),
+
+    Pid = rpc:call(CNode,?MODULE,wrap_test,[PNode,TestFun]),
+    MRef = erlang:monitor(process,Pid),
+    TO = ?TEST_DURATION*1000,
+    receive {'DOWN',MRef,_,_,Reason} ->
+            ct:fail({remote_pid_down,Reason})
+    after TO ->
+            All = ets:lookup_element(Tab,producer,2),
+            Written = ets:lookup_element(Tab,consumer,2),
+            dbg:stop_clear(),
+            ?COLLECT_STATS(All,
+                           [{PNode,P,Id} || {Id,P} <- _PStatProcs] ++
+                               [{CNode,P,Id} || {Id,P} <- _CStatProcs]),
+            Ratio = Written/All * 100,
+            ct_event:notify(#event{name = benchmark_data,
+                                   data = [{value,Ratio}]}),
+            {comment,io_lib:format("~p % (~p written, ~p produced)",
+                                   [round(Ratio),Written,All])}
+    end.
+
+wrap_test(Fun) ->
+    wrap_test(node(),Fun).
+wrap_test(Node,Fun) ->
+    reset(),
+    group_leader(whereis(user),self()),
+    rpc:call(Node,?MODULE,do_fun,[Fun]).
+
+do_fun(Fun) ->
+    reset(),
+    Fun().
+
+reset() ->
+    reset([logger_std_h_default, logger_disk_log_h_default, logger_proxy]).
+reset([P|Ps]) ->
+    is_pid(whereis(P)) andalso logger_olp:reset(P),
+    reset(Ps);
+reset([]) ->
+    ok.
+
+
+tracer({trace,_,call,{?MODULE,producer,_}},{Tab,_PNode,_CNode}=S) ->
+    ets:update_counter(Tab,producer,1),
+    S;
+tracer({trace,Pid,call,{logger_backend,log_allowed,_}},{Tab,PNode,_CNode}=S) when node(Pid)=:=PNode ->
+    ets:update_counter(Tab,producer,1),
+    S;
+tracer({trace,_,call,{?MODULE,log,_}},{Tab,_PNode,_CNode}=S) ->
+    ets:update_counter(Tab,consumer,1),
+    S;
+tracer({trace,_,call,{_,write,_}},{Tab,_PNode,_CNode}=S) ->
+    ets:update_counter(Tab,consumer,1),
+    S;
+tracer(_,S) ->
+    S.
+
+
+%%%-----------------------------------------------------------------
+%%% Collect statistics
+-define(STAT_KEYS,
+        [burst_drops,
+         calls,
+         casts,
+         drops,
+         flushed,
+         flushes,
+         freq,
+         last_qlen,
+         max_qlen,
+         time,
+         writes]).
+-define(EVENT_KEYS,
+        [calls,casts,flushed]).
+
+stats(All,Procs) ->
+    NI = [{Id,rpc:call(N,logger_olp,info,[P])} || {N,P,Id}<-Procs],
+    [{all,All}|[stats(Id,I,All) || {Id,I} <- NI]].
+
+stats(Id,Info,All) ->
+    S = maps:with(?STAT_KEYS,Info),
+    AllOnProc = lists:sum(maps:values(maps:with(?EVENT_KEYS,S))),
+    if All>0 ->
+            Writes = maps:get(writes,S),
+            {_,ActiveTime} = maps:get(time,S),
+            Rate = round(100*Writes/All),
+            RateOnProc =
+                if AllOnProc>0 ->
+                        round(100*Writes/AllOnProc);
+                   true ->
+                        0
+                end,
+            AvFreq =
+                if ActiveTime>0 ->
+                        round(Writes/ActiveTime);
+                   true ->
+                        0
+                end,
+            {Id,
+             {stats,S},
+             {rate,Rate},
+             {rate_on_proc,RateOnProc},
+             {av_freq,AvFreq}};
+       true ->
+            {Id,none}
+    end.
+
+%%%-----------------------------------------------------------------
+%%% Spawn a lot of processes that crash repeatedly, causing a lot of
+%%% error reports from the emulator.
+em_cascading() ->
+    spawn(fun() -> super() end).
+
+super() ->
+    process_flag(trap_exit,true),
+    spawn_link(fun server/0),
+    [spawn_link(fun client/0) || _<-lists:seq(1,10000)],
+    super_loop().
+
+super_loop() ->
+    receive
+        {'EXIT',_,server} ->
+            spawn_link(fun server/0),
+            super_loop();
+        {'EXIT',_,_} ->
+            _L = lists:sum(lists:seq(1,10000)),
+            spawn_link(fun client/0),
+            super_loop()
+    end.
+
+client() ->
+    receive
+    after 1 ->
+            case whereis(server) of
+                Pid when is_pid(Pid) ->
+                    ok;
+                undefined ->
+                    producer(),
+                    erlang:error(some_exception)
+            end
+    end,
+    client().
+
+server() ->
+    register(server,self()),
+    receive
+    after 3000 ->
+            exit(server)
+    end.
+        
+
+%%%-----------------------------------------------------------------
+%%% Create a supervisor tree with processes that crash repeatedly,
+%%% causing a lot of supervisor reports and crashreports
+otp_cascading() ->
+    {ok,Pid} = supervisor:start_link({local,otp_super}, ?MODULE, [otp_super]),
+    unlink(Pid),
+    Pid.
+
+otp_server_sup() ->
+    supervisor:start_link({local,otp_server_sup},?MODULE,[otp_server_sup]).
+
+otp_client_sup(N) ->
+    supervisor:start_link({local,otp_client_sup},?MODULE,[otp_client_sup,N]).
+
+otp_server() ->
+    gen_server:start_link({local,otp_server},?MODULE,[otp_server],[]).
+
+otp_client() ->
+    gen_server:start_link(?MODULE,[otp_client],[]).
+
+init([otp_super]) ->
+    {ok, {{one_for_one, 200, 10},
+            [{client_sup,
+                    {?MODULE, otp_client_sup, [10000]},
+                    permanent, 1000, supervisor, [?MODULE]},
+             {server_sup,
+                    {?MODULE, otp_server_sup, []},
+                    permanent, 1000, supervisor, [?MODULE]}
+            ]}};
+init([otp_server_sup]) ->
+    {ok, {{one_for_one, 2, 10},
+            [{server,
+                    {?MODULE, otp_server, []},
+                    permanent, 1000, worker, [?MODULE]}
+            ]}};
+init([otp_client_sup,N]) ->
+    spawn(fun() ->
+                  [supervisor:start_child(otp_client_sup,[])
+                   || _ <- lists:seq(1,N)]
+          end),
+    {ok, {{simple_one_for_one, N*10, 1},
+            [{client,
+                    {?MODULE, otp_client, []},
+                    permanent, 1000, worker, [?MODULE]}
+            ]}};
+init([otp_server]) ->
+    {ok, server, 10000};
+init([otp_client]) ->
+    {ok, client,1}.
+
+handle_info(timeout, client) ->
+    true = is_pid(whereis(otp_server)),
+    {noreply,client,1};
+handle_info(timeout, server) ->
+    exit(self(), some_error).
+
+%%%-----------------------------------------------------------------
+%%% Logger callbacks
+log(_LogEvent,_Config) ->
+    ok.
+
+%%%-----------------------------------------------------------------
+%%% Function to trace on for counting produced emulator messages
+producer() ->
+    ok.
diff --git a/lib/kernel/test/logger_test_lib.erl b/lib/kernel/test/logger_test_lib.erl
index 81eb9ce5eb..be4bc427fb 100644
--- a/lib/kernel/test/logger_test_lib.erl
+++ b/lib/kernel/test/logger_test_lib.erl
@@ -28,11 +28,17 @@
          post_end_per_testcase/5, post_end_per_suite/3]).
 
 setup(Config,Vars) ->
+    Postfix = case proplists:get_value(postfix, Config) of
+                  undefined -> "";
+                  P -> ["_",P]
+              end,
     FuncStr = lists:concat([proplists:get_value(suite, Config), "_",
-                            proplists:get_value(tc, Config)]),
+                            proplists:get_value(tc, Config)|
+                            Postfix]),
     ConfigFileName = filename:join(proplists:get_value(priv_dir, Config), FuncStr),
     file:write_file(ConfigFileName ++ ".config", io_lib:format("[{kernel, ~p}].",[Vars])),
-    case test_server:start_node(proplists:get_value(tc, Config), slave,
+    Sname = lists:concat([proplists:get_value(tc,Config)|Postfix]),
+    case test_server:start_node(Sname, slave,
                                 [{args, ["-pa ",filename:dirname(code:which(?MODULE)),
                                          " -boot start_sasl -kernel start_timer true "
                                          "-config ",ConfigFileName]}]) of