[logger] Refactor logger_std_h

2 files changed, 53 insertions, 56 deletions

diff --git a/lib/kernel/src/logger_std_h.erl b/lib/kernel/src/logger_std_h.erl
index 04e7f6ad83..392ac7e67b 100644
--- a/lib/kernel/src/logger_std_h.erl
+++ b/lib/kernel/src/logger_std_h.erl
@@ -242,11 +242,12 @@ do_open_log_file({file,FileName,Modes}) ->
         _:Reason -> {error,Reason}
     end.
 
-close_log_file(Std) when Std == standard_io; Std == standard_error ->
-    ok;
-close_log_file({Fd,_}) ->
+close_log_file(#{file:={Fd,_}}) ->
     _ = file:datasync(Fd),
-    _ = file:close(Fd).
+    _ = file:close(Fd);
+close_log_file(_) ->
+    ok.
+
 
 
 %%%-----------------------------------------------------------------
@@ -305,14 +306,19 @@ file_ctrl_init(HandlerName, FileInfo, Starter) when is_tuple(FileInfo) ->
         {ok,File} ->
             Starter ! {self(),ok},
             FileInfo1 = set_file_opt_append(FileInfo),
-            file_ctrl_loop(File, FileInfo1, false, ok, ok, HandlerName);
+            file_ctrl_loop(#{name=>HandlerName,
+                             file=>File,
+                             file_info=>FileInfo1,
+                             synced=>false,
+                             write_res=>ok,
+                             sync_res=>ok});
         {error,Reason} ->
             FileName = element(2, FileInfo),
             Starter ! {self(),{error,{open_failed,FileName,Reason}}}
     end;
 file_ctrl_init(HandlerName, StdDev, Starter) ->
     Starter ! {self(),ok},
-    file_ctrl_loop(StdDev, StdDev, false, ok, ok, HandlerName).
+    file_ctrl_loop(#{name=>HandlerName,dev=>StdDev}).
 
 %% Modify file options to use when re-opening if the inode has
 %% changed. I.e. the file may exist and if so should be appended to.
@@ -321,86 +327,77 @@ set_file_opt_append({file, FileName, Modes}) ->
 set_file_opt_append(FileInfo) ->
     FileInfo.
 
-file_ctrl_loop(File, FileInfo, Synced,
-               PrevWriteResult, PrevSyncResult, HandlerName) ->
+file_ctrl_loop(State) ->
     receive
         %% asynchronous event
         {log,Bin} ->
-            File1 = ensure(File, FileInfo),
-            Result = write_to_dev(File1, Bin, FileInfo,
-                                  PrevWriteResult, HandlerName),
-            file_ctrl_loop(File1, FileInfo, false,
-                           Result, PrevSyncResult, HandlerName);
+            State1 = write_to_dev(Bin,State),
+            file_ctrl_loop(State1);
 
         %% synchronous event
         {{log,Bin},{From,MRef}} ->
-            File1 = ensure(File, FileInfo),
-            Result = write_to_dev(File1, Bin, FileInfo,
-                                  PrevWriteResult, HandlerName),
+            State1 = write_to_dev(Bin,State),
             From ! {MRef,ok},
-            file_ctrl_loop(File1, FileInfo, false,
-                           Result, PrevSyncResult, HandlerName);
+            file_ctrl_loop(State1);
 
         filesync ->
-            File1 = ensure(File, FileInfo),
-            Result = sync_dev(File1, FileInfo, Synced,
-                              PrevSyncResult, HandlerName),
-            file_ctrl_loop(File1, FileInfo, true,
-                           PrevWriteResult, Result, HandlerName);
+            State1 = sync_dev(State),
+            file_ctrl_loop(State1);
 
         {filesync,{From,MRef}} ->
-            File1 = ensure(File, FileInfo),
-            Result = sync_dev(File1, FileInfo, Synced,
-                              PrevSyncResult, HandlerName),
+            State1 = sync_dev(State),
             From ! {MRef,ok},
-            file_ctrl_loop(File1, FileInfo, true,
-                           PrevWriteResult, Result, HandlerName);
+            file_ctrl_loop(State1);
 
         stop ->
-            _ = close_log_file(File),
+            _ = close_log_file(State),
             stopped
     end.
 
+write_to_dev(Bin,#{dev:=DevName}=State) ->
+    io:put_chars(DevName, Bin),
+    State;
+write_to_dev(Bin, State) ->
+    State1 = #{file:={Fd,_}} = ensure_file(State),
+    Result = ?file_write(Fd, Bin),
+    maybe_notify_error(write,Result,State1),
+    State1#{synced=>false,write_res=>Result}.
+
+sync_dev(#{synced:=false}=State) ->
+    State1 = #{file:={Fd,_}} = ensure_file(State),
+    Result = ?file_datasync(Fd),
+    maybe_notify_error(filesync,Result,State1),
+    State1#{synced=>true,sync_res=>Result};
+sync_dev(State) ->
+    State.
+
 %% In order to play well with tools like logrotate, we need to be able
 %% to re-create the file if it has disappeared (e.g. if rotated by
 %% logrotate)
-ensure(Fd,DevName) when is_atom(DevName) ->
-    Fd;
-ensure({Fd,INode},FileInfo) ->
+ensure_file(#{file:={Fd,INode},file_info:=FileInfo}=State) ->
     FileName = element(2, FileInfo),
     case file:read_file_info(FileName) of
         {ok,#file_info{inode=INode}} ->
-            {Fd,INode};
+            State;
         _ ->
             _ = file:close(Fd),
             _ = file:close(Fd), % delayed_write cause close not to close
             case do_open_log_file(FileInfo) of
                 {ok,File} ->
-                    File;
+                    State#{file=>File};
                 Error ->
                     exit({could_not_reopen_file,Error})
             end
     end.
 
-write_to_dev(DevName, Bin, _DevName, _PrevWriteResult, _HandlerName)
-  when is_atom(DevName) ->
-    io:put_chars(DevName, Bin);
-write_to_dev({Fd,_}, Bin, FileInfo, PrevWriteResult, HandlerName) ->
-    Result = ?file_write(Fd, Bin),
-    maybe_notify_error(write,Result,PrevWriteResult,FileInfo,HandlerName).
-
-sync_dev(_, _FileInfo, true, PrevSyncResult, _HandlerName) ->
-    PrevSyncResult;
-sync_dev({Fd,_}, FileInfo, false, PrevSyncResult, HandlerName) ->
-    Result = ?file_datasync(Fd),
-    maybe_notify_error(filesync,Result,PrevSyncResult,FileInfo,HandlerName).
-
-maybe_notify_error(_Op, ok, _PrevResult, _FileInfo, _HandlerName) ->
+maybe_notify_error(_Op, ok, _State) ->
     ok;
-maybe_notify_error(_Op, PrevResult, PrevResult, _FileInfo, _HandlerName) ->
+maybe_notify_error(Op, Result, #{write_res:=WR,sync_res:=SR})
+  when (Op==write andalso Result==WR) orelse
+       (Op==filesync andalso Result==SR) ->
     %% don't report same error twice
-    PrevResult;
-maybe_notify_error(Op, Error, _PrevResult, FileInfo, HandlerName) ->
+    ok;
+maybe_notify_error(Op, Error, #{name:=HandlerName,file_info:=FileInfo}) ->
     FileName = element(2, FileInfo),
     logger_h_common:error_notify({HandlerName,Op,FileName,Error}),
-    Error.
+    ok.
diff --git a/lib/kernel/test/logger_std_h_SUITE.erl b/lib/kernel/test/logger_std_h_SUITE.erl
index b2c2c8ba67..ba491ac5fa 100644
--- a/lib/kernel/test/logger_std_h_SUITE.erl
+++ b/lib/kernel/test/logger_std_h_SUITE.erl
@@ -646,7 +646,7 @@ sync(Config) ->
                               formatter=>{?MODULE,nl}}),
 
     %% check repeated filesync happens
-    start_tracer([{logger_std_h, write_to_dev, 5},
+    start_tracer([{logger_std_h, write_to_dev, 2},
                   {file, datasync, 1}],
                  [{logger_std_h, write_to_dev, <<"first\n">>},
                   {file,datasync}]),
@@ -656,7 +656,7 @@ sync(Config) ->
     check_tracer(filesync_rep_int()*2),
 
     %% check that explicit filesync is only done once
-    start_tracer([{logger_std_h, write_to_dev, 5},
+    start_tracer([{logger_std_h, write_to_dev, 2},
                   {file, datasync, 1}],
                  [{logger_std_h, write_to_dev, <<"second\n">>},
                   {file,datasync},
@@ -675,7 +675,7 @@ sync(Config) ->
                                       #{filesync_repeat_interval => no_repeat}),
     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},
+    start_tracer([{logger_std_h, write_to_dev, 2},
                   {file, datasync, 1}],
                  [{logger_std_h, write_to_dev, <<"third\n">>},
                   {file,datasync},
@@ -1658,7 +1658,7 @@ tpl([]) ->
 tracer({trace,_,call,{logger_h_common,handle_cast,[Op|_]}},
        {Pid,[{Mod,Func,Op}|Expected]}) ->
     maybe_tracer_done(Pid,Expected,{Mod,Func,Op});
-tracer({trace,_,call,{Mod=logger_std_h,Func=write_to_dev,[_,Data,_,_,_]}},
+tracer({trace,_,call,{Mod=logger_std_h,Func=write_to_dev,[Data,_]}},
        {Pid,[{Mod,Func,Data}|Expected]}) ->
     maybe_tracer_done(Pid,Expected,{Mod,Func,Data});
 tracer({trace,_,call,{Mod,Func,_}}, {Pid,[{Mod,Func}|Expected]}) ->