%% %% %CopyrightBegin% %% %% Copyright Ericsson AB 2017. 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_std_h). -behaviour(gen_server). -include("logger.hrl"). -include("logger_internal.hrl"). -include("logger_h_common.hrl"). -include_lib("kernel/include/file.hrl"). %% API -export([start_link/3, info/1, sync/1, reset/1]). %% gen_server and proc_lib callbacks -export([init/1, handle_call/3, handle_cast/2, handle_info/2, terminate/2, code_change/3]). %% logger callbacks -export([log/2, adding_handler/1, removing_handler/1, changing_config/2]). %% handler internal -export([log_handler_info/4]). %%%=================================================================== %%% API %%%=================================================================== %%%----------------------------------------------------------------- %%% Start a standard handler process and link to caller. %%% This function is called by the kernel supervisor when this %%% handler process gets added -spec start_link(Name, Config, HandlerState) -> {ok,Pid} | {error,Reason} when Name :: atom(), Config :: logger:handler_config(), HandlerState :: map(), Pid :: pid(), Reason :: term(). start_link(Name, Config, HandlerState) -> proc_lib:start_link(?MODULE,init,[[Name,Config,HandlerState]]). %%%----------------------------------------------------------------- %%% -spec sync(Name) -> ok | {error,Reason} when Name :: atom(), Reason :: handler_busy | {badarg,term()}. sync(Name) when is_atom(Name) -> try gen_server:call(?name_to_reg_name(?MODULE,Name), filesync, ?DEFAULT_CALL_TIMEOUT) catch _:{timeout,_} -> {error,handler_busy} end; sync(Name) -> {error,{badarg,{sync,[Name]}}}. %%%----------------------------------------------------------------- %%% -spec info(Name) -> Info | {error,Reason} when Name :: atom(), Info :: term(), Reason :: handler_busy | {badarg,term()}. info(Name) when is_atom(Name) -> try gen_server:call(?name_to_reg_name(?MODULE,Name), info, ?DEFAULT_CALL_TIMEOUT) catch _:{timeout,_} -> {error,handler_busy} end; info(Name) -> {error,{badarg,{info,[Name]}}}. %%%----------------------------------------------------------------- %%% -spec reset(Name) -> ok | {error,Reason} when Name :: atom(), Reason :: handler_busy | {badarg,term()}. reset(Name) when is_atom(Name) -> try gen_server:call(?name_to_reg_name(?MODULE,Name), reset, ?DEFAULT_CALL_TIMEOUT) catch _:{timeout,_} -> {error,handler_busy} end; reset(Name) -> {error,{badarg,{reset,[Name]}}}. %%%=================================================================== %%% logger callbacks %%%=================================================================== %%%----------------------------------------------------------------- %%% Handler being added adding_handler(#{id:=Name}=Config) -> case check_config(adding, Config) of {ok, Config1} -> %% create initial handler state by merging defaults with config HConfig = maps:get(config, Config1, #{}), HState = maps:merge(get_init_state(), HConfig), case logger_h_common:overload_levels_ok(HState) of true -> start(Name, Config1, HState); false -> #{sync_mode_qlen := SMQL, drop_mode_qlen := DMQL, flush_qlen := FQL} = HState, {error,{invalid_levels,{SMQL,DMQL,FQL}}} end; Error -> Error end. %%%----------------------------------------------------------------- %%% Updating handler config changing_config(OldConfig=#{id:=Name, config:=HConfig}, NewConfig=#{id:=Name}) -> #{type:=Type, handler_pid:=HPid, mode_tab:=ModeTab} = HConfig, MyConfig = maps:get(config, NewConfig, #{}), case maps:get(type, MyConfig, Type) of Type -> MyConfig1 = MyConfig#{type=>Type, handler_pid=>HPid, mode_tab=>ModeTab}, changing_config1(HPid, OldConfig, NewConfig#{config=>MyConfig1}); _ -> {error,{illegal_config_change,OldConfig,NewConfig}} end; changing_config(OldConfig, NewConfig) -> {error,{illegal_config_change,OldConfig,NewConfig}}. changing_config1(HPid, OldConfig, NewConfig) -> case check_config(changing, NewConfig) of Result = {ok,NewConfig1} -> try gen_server:call(HPid, {change_config,OldConfig,NewConfig1}, ?DEFAULT_CALL_TIMEOUT) of ok -> Result; HError -> HError catch _:{timeout,_} -> {error,handler_busy} end; Error -> Error end. check_config(adding, Config) -> %% Merge in defaults on handler level MyConfig0 = maps:get(config, Config, #{}), MyConfig = maps:merge(#{type => standard_io}, MyConfig0), case check_my_config(maps:to_list(MyConfig)) of ok -> {ok,Config#{config=>MyConfig}}; Error -> Error end; check_config(changing, Config) -> MyConfig = maps:get(config, Config, #{}), case check_my_config(maps:to_list(MyConfig)) of ok -> {ok,Config}; Error -> Error end. check_my_config([{type,Type} | Config]) when Type == standard_io; Type == standard_error -> check_my_config(Config); check_my_config([{type,{file,File}} | Config]) when is_list(File) -> check_my_config(Config); check_my_config([{type,{file,File,Modes}} | Config]) when is_list(File), is_list(Modes) -> check_my_config(Config); check_my_config([Other | Config]) -> case logger_h_common:check_common_config(Other) of valid -> check_my_config(Config); invalid -> {error,{invalid_config,?MODULE,Other}} end; check_my_config([]) -> ok. %%%----------------------------------------------------------------- %%% Handler being removed removing_handler(#{id:=Name}) -> stop(Name). %%%----------------------------------------------------------------- %%% Log a string or report -spec log(LogEvent, Config) -> ok | dropped when LogEvent :: logger:log_event(), Config :: logger:handler_config(). log(LogEvent, Config = #{id := Name, config := #{handler_pid := HPid, mode_tab := ModeTab}}) -> %% if the handler has crashed, we must drop this event %% and hope the handler restarts so we can try again true = is_process_alive(HPid), Bin = logger_h_common:log_to_binary(LogEvent, Config), logger_h_common:call_cast_or_drop(Name, HPid, ModeTab, Bin). %%%=================================================================== %%% gen_server callbacks %%%=================================================================== init([Name, Config = #{config := HConfig}, State0 = #{type := Type, file_ctrl_sync_int := FileCtrlSyncInt}]) -> register(?name_to_reg_name(?MODULE,Name), self()), process_flag(trap_exit, true), process_flag(message_queue_data, off_heap), ?init_test_hooks(), ?start_observation(Name), case do_init(Name, Type) of {ok,InitState} -> try ets:new(Name, [public]) of ModeTab -> ?set_mode(ModeTab, async), State = maps:merge(State0, InitState), T0 = ?timestamp(), State1 = ?merge_with_stats(State#{ mode_tab => ModeTab, mode => async, file_ctrl_sync => FileCtrlSyncInt, last_qlen => 0, last_log_ts => T0, last_op => sync, burst_win_ts => T0, burst_msg_count => 0}), Config1 = Config#{config => HConfig#{handler_pid => self(), mode_tab => ModeTab}}, proc_lib:init_ack({ok,self(),Config1}), gen_server:cast(self(), repeated_filesync), enter_loop(Config1, State1) catch _:Error -> logger_h_common:error_notify({init_handler,Name,Error}), proc_lib:init_ack(Error) end; Error -> logger_h_common:error_notify({init_handler,Name,Error}), proc_lib:init_ack(Error) end. do_init(Name, Type) -> case open_log_file(Name, Type) of {ok,FileCtrlPid} -> case logger_h_common:unset_restart_flag(Name, ?MODULE) of true -> %% inform about restart gen_server:cast(self(), {log_handler_info, "Handler ~p restarted", [Name]}); false -> %% initial start ok end, {ok,#{id=>Name,type=>Type,file_ctrl_pid=>FileCtrlPid}}; Error -> Error end. enter_loop(_Config,State) -> gen_server:enter_loop(?MODULE,[],State). %% This is the synchronous log event. handle_call({log, Bin}, _From, State) -> {Result,State1} = do_log(Bin, call, State), %% Result == ok | dropped {reply,Result, State1}; handle_call(filesync, _From, State = #{type := Type, file_ctrl_pid := FileCtrlPid}) -> if is_atom(Type) -> {reply, ok, State}; true -> {reply, file_ctrl_filesync_sync(FileCtrlPid), State#{last_op=>sync}} end; handle_call({change_config,_OldConfig,NewConfig}, _From, State = #{filesync_repeat_interval := FSyncInt0}) -> HConfig = maps:get(config, NewConfig, #{}), State1 = maps:merge(State, HConfig), case logger_h_common:overload_levels_ok(State1) of true -> _ = case maps:get(filesync_repeat_interval, HConfig, undefined) of undefined -> ok; no_repeat -> _ = logger_h_common:cancel_timer(maps:get(rep_sync_tref, State, undefined)); FSyncInt0 -> ok; _FSyncInt1 -> _ = logger_h_common:cancel_timer(maps:get(rep_sync_tref, State, undefined)), gen_server:cast(self(), repeated_filesync) end, {reply, ok, State1}; false -> #{sync_mode_qlen := SMQL, drop_mode_qlen := DMQL, flush_qlen := FQL} = State1, {reply, {error,{invalid_levels,{SMQL,DMQL,FQL}}}, State} end; handle_call(info, _From, State) -> {reply, State, State}; handle_call(reset, _From, State) -> State1 = ?merge_with_stats(State), {reply, ok, State1#{last_qlen => 0, last_log_ts => ?timestamp()}}; handle_call(stop, _From, State) -> {stop, {shutdown,stopped}, ok, State}. %% This is the asynchronous log event. handle_cast({log, Bin}, State) -> {_,State1} = do_log(Bin, cast, State), {noreply, State1}; handle_cast({log_handler_info, Format, Args}, State = #{id:=Name}) -> log_handler_info(Name, Format, Args, State), {noreply, State}; %% If FILESYNC_REPEAT_INTERVAL is set to a millisec value, this %% clause gets called repeatedly by the handler. In order to %% guarantee that a filesync *always* happens after the last log %% event, the repeat operation must be active! handle_cast(repeated_filesync, State = #{type := Type, file_ctrl_pid := FileCtrlPid, filesync_repeat_interval := FSyncInt, last_op := LastOp}) -> State1 = if not is_atom(Type), is_integer(FSyncInt) -> %% only do filesync if something has been %% written since last time we checked if LastOp == sync -> ok; true -> file_ctrl_filesync_async(FileCtrlPid) end, {ok,TRef} = timer:apply_after(FSyncInt, gen_server,cast, [self(),repeated_filesync]), State#{rep_sync_tref => TRef, last_op => sync}; true -> State end, {noreply,State1}. handle_info({'EXIT',Pid,Why}, State = #{id := Name, type := FileInfo}) -> case maps:get(file_ctrl_pid, State, undefined) of Pid -> %% file error, terminate handler logger_h_common:handler_exit(Name, {error,{write_failed,FileInfo,Why}}); _Other -> %% ignore EXIT ok end, {noreply, State}; handle_info(_Info, State) -> {noreply, State}. terminate(Reason, State = #{id:=Name, file_ctrl_pid:=FWPid, type:=_FileInfo}) -> _ = logger_h_common:cancel_timer(maps:get(rep_sync_tref, State, undefined)), case is_process_alive(FWPid) of true -> unlink(FWPid), _ = file_ctrl_stop(FWPid), MRef = erlang:monitor(process, FWPid), receive {'DOWN',MRef,_,_,_} -> ok after ?DEFAULT_CALL_TIMEOUT -> exit(FWPid, kill) end; false -> ok end, logger_h_common:stop_or_restart(Name, Reason, State). code_change(_OldVsn, State, _Extra) -> {ok, State}. %%%=================================================================== %%% Internal functions %%%=================================================================== %%%----------------------------------------------------------------- %%% get_init_state() -> #{sync_mode_qlen => ?SYNC_MODE_QLEN, drop_mode_qlen => ?DROP_MODE_QLEN, flush_qlen => ?FLUSH_QLEN, burst_limit_enable => ?BURST_LIMIT_ENABLE, burst_limit_max_count => ?BURST_LIMIT_MAX_COUNT, burst_limit_window_time => ?BURST_LIMIT_WINDOW_TIME, 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, file_ctrl_sync_int => ?CONTROLLER_SYNC_INTERVAL, filesync_ok_qlen => ?FILESYNC_OK_QLEN, filesync_repeat_interval => ?FILESYNC_REPEAT_INTERVAL}. %%%----------------------------------------------------------------- %%% Add a standard handler to the logger. %%% This starts a dedicated handler process which should always %%% exist if the handler is registered with logger (and should not %%% exist if the handler is not registered). %%% %%% Handler specific config should be provided with a sub map associated %%% with a key named 'config', e.g: %%% %%% Config = #{config => #{sync_mode_qlen => 50} %%% %%% The standard handler process is linked to logger_sup, which is %%% part of the kernel application's supervision tree. start(Name, Config, HandlerState) -> LoggerStdH = #{id => Name, start => {?MODULE, start_link, [Name,Config,HandlerState]}, restart => temporary, shutdown => 2000, type => worker, modules => [?MODULE]}, case supervisor:start_child(logger_sup, LoggerStdH) of {ok,_Pid,Config1} -> {ok,Config1}; Error -> Error end. %%%----------------------------------------------------------------- %%% Stop and remove the handler. stop(Name) -> case whereis(?name_to_reg_name(?MODULE,Name)) of undefined -> ok; Pid -> %% We don't want to do supervisor:terminate_child here %% since we need to distinguish this explicit stop from a %% system termination in order to avoid circular attempts %% at removing the handler (implying deadlocks and %% timeouts). _ = gen_server:call(Pid, stop), _ = supervisor:delete_child(logger_sup, Name), ok end. %%%----------------------------------------------------------------- %%% Logging and overload control. -define(update_file_ctrl_sync(C, Interval), if C == 0 -> Interval; true -> C-1 end). %% check for overload between every event (and set Mode to async, %% sync or drop accordingly), but never flush the whole mailbox %% before LogWindowSize events have been handled do_log(Bin, CallOrCast, State = #{id:=Name, mode:=Mode0}) -> T1 = ?timestamp(), %% check if the handler is getting overloaded, or if it's %% recovering from overload (the check must be done for each %% event to react quickly to large bursts of events and %% to ensure that the handler can never end up in drop mode %% with an empty mailbox, which would stop operation) {Mode1,QLen,Mem,State1} = logger_h_common:check_load(State), if (Mode1 == drop) andalso (Mode0 =/= drop) -> log_handler_info(Name, "Handler ~p switched to drop mode", [Name], State); (Mode0 == drop) andalso ((Mode1 == async) orelse (Mode1 == sync)) -> log_handler_info(Name, "Handler ~p switched to ~w mode", [Name,Mode1], State); true -> ok end, %% kill the handler if it can't keep up with the load logger_h_common:kill_if_choked(Name, QLen, Mem, ?MODULE, State), if Mode1 == flush -> flush(Name, QLen, T1, State1); true -> write(Name, Mode1, T1, Bin, CallOrCast, State1) end. %% this clause is called by do_log/3 after an overload check %% has been performed, where QLen > FlushQLen flush(Name, _QLen0, T1, State=#{last_log_ts := _T0, mode_tab := ModeTab}) -> %% flush messages in the mailbox (a limited number in %% order to not cause long delays) NewFlushed = logger_h_common:flush_log_events(?FLUSH_MAX_N), %% write info in log about flushed messages log_handler_info(Name, "Handler ~p flushed ~w log events", [Name,NewFlushed], State), %% because of the receive loop when flushing messages, the %% handler will be scheduled out often and the mailbox could %% grow very large, so we'd better check the queue again here {_,_QLen1} = process_info(self(), message_queue_len), ?observe(Name,{max_qlen,_QLen1}), %% Add 1 for the current log event ?observe(Name,{flushed,NewFlushed+1}), State1 = ?update_max_time(?diff_time(T1,_T0),State), {dropped,?update_other(flushed,FLUSHED,NewFlushed, State1#{mode => ?set_mode(ModeTab,async), last_qlen => 0, last_log_ts => T1})}. %% this clause is called to write to file write(_Name, Mode, T1, Bin, _CallOrCast, State = #{mode_tab := ModeTab, file_ctrl_pid := FileCtrlPid, file_ctrl_sync := FileCtrlSync, last_qlen := LastQLen, last_log_ts := T0, file_ctrl_sync_int := FileCtrlSyncInt}) -> %% check if we need to limit the number of writes %% during a burst of log events {DoWrite,BurstWinT,BurstMsgCount} = logger_h_common:limit_burst(State), %% only send a synhrounous event to the file controller process %% every FileCtrlSyncInt time, to give the handler time between %% file writes so it can keep up with incoming messages {Result,LastQLen1} = if DoWrite, FileCtrlSync == 0 -> ?observe(_Name,{_CallOrCast,1}), file_write_sync(FileCtrlPid, Bin, false), {ok,element(2, process_info(self(), message_queue_len))}; DoWrite -> ?observe(_Name,{_CallOrCast,1}), file_write_async(FileCtrlPid, Bin), {ok,LastQLen}; not DoWrite -> ?observe(_Name,{flushed,1}), {dropped,LastQLen} end, %% Check if the time since the previous log event is long enough - %% and the queue length small enough - to assume the mailbox has %% been emptied, and if so, do filesync operation and reset mode to %% async. Note that this is the best we can do to detect an idle %% handler without setting a timer after each log call/cast. If the %% time between two consecutive log events is fast and no new %% event comes in after the last one, idle state won't be detected! Time = ?diff_time(T1,T0), {Mode1,BurstMsgCount1} = if (LastQLen1 < ?FILESYNC_OK_QLEN) andalso (Time > ?IDLE_DETECT_TIME_USEC) -> %% do filesync if necessary case maps:get(type, State) of Std when is_atom(Std) -> ok; _File -> file_ctrl_filesync_async(FileCtrlPid) end, {?change_mode(ModeTab, Mode, async),0}; true -> {Mode,BurstMsgCount} end, State1 = ?update_calls_or_casts(_CallOrCast,1,State), State2 = ?update_max_time(Time, State1#{mode => Mode1, last_qlen := LastQLen1, last_log_ts => T1, last_op => write, burst_win_ts => BurstWinT, burst_msg_count => BurstMsgCount1, file_ctrl_sync => ?update_file_ctrl_sync(FileCtrlSync, FileCtrlSyncInt)}), {Result,State2}. open_log_file(HandlerName, FileInfo) -> case file_ctrl_start(HandlerName, FileInfo) of OK = {ok,_FileCtrlPid} -> OK; Error -> Error end. do_open_log_file({file,File}) -> do_open_log_file({file,File,[raw,append,delayed_write]}); do_open_log_file({file,File,[]}) -> do_open_log_file({file,File,[raw,append,delayed_write]}); do_open_log_file({file,File,Modes}) -> try case filelib:ensure_dir(File) of ok -> file:open(File, Modes); Error -> Error end catch _:Reason -> {error,Reason} end. close_log_file(Std) when Std == standard_io; Std == standard_error -> ok; close_log_file(Fd) -> _ = file:datasync(Fd), _ = file:close(Fd). log_handler_info(Name, Format, Args, #{file_ctrl_pid := FileCtrlPid}) -> Config = case logger:get_handler_config(Name) of {ok,Conf} -> Conf; _ -> #{formatter=>{?DEFAULT_FORMATTER,?DEFAULT_FORMAT_CONFIG}} end, Meta = #{time=>erlang:system_time(microsecond)}, Bin = logger_h_common:log_to_binary(#{level => notice, msg => {Format,Args}, meta => Meta}, Config), _ = file_write_async(FileCtrlPid, Bin), ok. %%%----------------------------------------------------------------- %%% File control process file_ctrl_start(HandlerName, FileInfo) -> Starter = self(), FileCtrlPid = spawn_link(fun() -> file_ctrl_init(HandlerName, FileInfo, Starter) end), receive {FileCtrlPid,ok} -> {ok,FileCtrlPid}; {FileCtrlPid,Error} -> Error after ?DEFAULT_CALL_TIMEOUT -> {error,file_ctrl_process_not_started} end. file_ctrl_stop(Pid) -> Pid ! stop. file_write_async(Pid, Bin) -> Pid ! {log,Bin}, ok. file_write_sync(Pid, Bin, FileSync) -> case file_ctrl_call(Pid, {log,self(),Bin,FileSync}) of {error,Reason} -> {error,{write_failed,Bin,Reason}}; Result -> Result end. file_ctrl_filesync_async(Pid) -> Pid ! filesync, ok. file_ctrl_filesync_sync(Pid) -> file_ctrl_call(Pid, {filesync,self()}). file_ctrl_call(Pid, Msg) -> MRef = monitor(process, Pid), Pid ! {Msg,MRef}, receive {MRef,Result} -> demonitor(MRef, [flush]), Result; {'DOWN',MRef,_Type,_Object,Reason} -> {error,Reason} after ?DEFAULT_CALL_TIMEOUT -> {error,{no_response,Pid}} end. file_ctrl_init(HandlerName, FileInfo, Starter) when is_tuple(FileInfo) -> process_flag(message_queue_data, off_heap), FileName = element(2, FileInfo), case do_open_log_file(FileInfo) of {ok,Fd} -> Starter ! {self(),ok}, file_ctrl_loop(Fd, file, FileName, false, ok, ok, HandlerName); {error,Reason} -> Starter ! {self(),{error,{open_failed,FileName,Reason}}} end; file_ctrl_init(HandlerName, StdDev, Starter) -> Starter ! {self(),ok}, file_ctrl_loop(StdDev, standard_io, StdDev, false, ok, ok, HandlerName). file_ctrl_loop(Fd, Type, DevName, Synced, PrevWriteResult, PrevSyncResult, HandlerName) -> receive %% asynchronous event {log,Bin} -> Result = if Type == file -> write_to_dev(Fd, Bin, DevName, PrevWriteResult, HandlerName); true -> io:put_chars(Fd, Bin) end, file_ctrl_loop(Fd, Type, DevName, false, Result, PrevSyncResult, HandlerName); %% synchronous event {{log,From,Bin,FileSync},MRef} -> if Type == file -> %% check that file hasn't been deleted CheckFile = fun() -> {ok,_} = file:read_file_info(DevName) end, spawn_link(CheckFile), WResult = write_to_dev(Fd, Bin, DevName, PrevWriteResult, HandlerName), {Synced1,SResult} = if not FileSync -> {false,PrevSyncResult}; true -> case sync_dev(Fd, DevName, PrevSyncResult, HandlerName) of ok -> {true,ok}; Error -> {false,Error} end end, From ! {MRef,ok}, file_ctrl_loop(Fd, Type, DevName, Synced1, WResult, SResult, HandlerName); true -> _ = io:put_chars(Fd, Bin), From ! {MRef,ok}, file_ctrl_loop(Fd, Type, DevName, false, ok, PrevSyncResult, HandlerName) end; filesync when not Synced -> Result = sync_dev(Fd, DevName, PrevSyncResult, HandlerName), file_ctrl_loop(Fd, Type, DevName, true, PrevWriteResult, Result, HandlerName); filesync -> file_ctrl_loop(Fd, Type, DevName, true, PrevWriteResult, PrevSyncResult, HandlerName); {{filesync,From},MRef} -> Result = if not Synced -> sync_dev(Fd, DevName, PrevSyncResult, HandlerName); true -> ok end, From ! {MRef,ok}, file_ctrl_loop(Fd, Type, DevName, true, PrevWriteResult, Result, HandlerName); stop -> _ = close_log_file(Fd), stopped end. write_to_dev(Fd, Bin, FileName, PrevWriteResult, HandlerName) -> case ?file_write(Fd, Bin) of ok -> ok; PrevWriteResult -> %% don't report same error twice PrevWriteResult; Error -> logger_h_common:error_notify({HandlerName,write,FileName,Error}), Error end. sync_dev(Fd, DevName, PrevSyncResult, HandlerName) -> case ?file_datasync(Fd) of ok -> ok; PrevSyncResult -> %% don't report same error twice PrevSyncResult; Error -> logger_h_common:error_notify({HandlerName,sync,DevName,Error}), Error end.