%% %% %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_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)). suite() -> [{timetrap,{seconds,30}}]. init_per_suite(Config) -> case logger:get_handler_config(?STANDARD_HANDLER) of {ok,StdH} -> ok = logger:remove_handler(?STANDARD_HANDLER), [{default_handler,StdH}|Config]; _ -> Config end. end_per_suite(Config) -> case ?config(default_handler,Config) of {HMod,HConfig} -> ok = logger:add_handler(?STANDARD_HANDLER,HMod,HConfig); _ -> ok end. init_per_group(_Group, Config) -> Config. end_per_group(_Group, _Config) -> ok. init_per_testcase(_TestCase, Config) -> {ok,LC} = logger:get_logger_config(), [{logger_config,LC}|Config]. end_per_testcase(Case, Config) -> try apply(?MODULE,Case,[cleanup,Config]) catch error:undef -> ok end, ok. groups() -> []. all() -> [start_stop, add_remove_handler, multiple_handlers, add_remove_filter, change_config, set_formatter, log_no_levels, log_all_levels_api, macros, set_level, set_module_level, cache_module_level, format_report, filter_failed, handler_failed, config_sanity_check, log_failed, emulator, via_logger_process, other_node, compare_levels, process_metadata]. start_stop(_Config) -> S = whereis(logger), true = is_pid(S), ok. add_remove_handler(_Config) -> register(callback_receiver,self()), #{handlers:=Hs0} = logger:i(), {error,{not_found,h1}} = logger:get_handler_config(h1), ok = logger:add_handler(h1,?MODULE,#{}), [add] = test_server:messages_get(), #{handlers:=Hs} = logger:i(), {value,_,Hs0} = lists:keytake(h1,1,Hs), {ok,{?MODULE,#{level:=all,filters:=[],filter_default:=log}}} = % defaults logger:get_handler_config(h1), ok = logger:set_handler_config(h1,filter_default,stop), [changing_config] = test_server:messages_get(), ?LOG_INFO("hello",[]), ok = check_no_log(), ok = logger:set_handler_config(h1,filter_default,log), [changing_config] = test_server:messages_get(), {ok,{?MODULE,#{filter_default:=log}}} = logger:get_handler_config(h1), ?LOG_INFO("hello",[]), ok = check_logged(info,"hello",[],?MY_LOC(1)), ok = logger:remove_handler(h1), [remove] = test_server:messages_get(), #{handlers:=Hs0} = logger:i(), {error,{not_found,h1}} = logger:get_handler_config(h1), {error,{not_found,h1}} = logger:remove_handler(h1), logger:info("hello",[]), ok = check_no_log(), ok. add_remove_handler(cleanup,_Config) -> logger:remove_handler(h1), ok. multiple_handlers(_Config) -> ok = logger:add_handler(h1,?MODULE,#{level=>info,filter_default=>log}), ok = logger:add_handler(h2,?MODULE,#{level=>error,filter_default=>log}), ?LOG_ERROR("hello",[]), ok = check_logged(error,"hello",[],?MY_LOC(1)), ok = check_logged(error,"hello",[],?MY_LOC(2)), ?LOG_INFO("hello",[]), ok = check_logged(info,"hello",[],?MY_LOC(1)), ok = check_no_log(), ok. multiple_handlers(cleanup,_Config) -> logger:remove_handler(h1), logger:remove_handler(h2), ok. add_remove_filter(_Config) -> ok = logger:add_handler(h1,?MODULE,#{level=>info,filter_default=>log}), LF = {fun(Log,_) -> Log#{level=>error} end, []}, ok = logger:add_logger_filter(lf,LF), {error,{already_exist,lf}} = logger:add_logger_filter(lf,LF), {error,{already_exist,lf}} = logger:add_logger_filter(lf,{fun(Log,_) -> Log end, []}), ?LOG_INFO("hello",[]), ok = check_logged(error,"hello",[],?MY_LOC(1)), ok = check_no_log(), ok = logger:add_handler(h2,?MODULE,#{level=>info,filter_default=>log}), HF = {fun(#{level:=error}=Log,_) -> Log#{level=>mylevel}; (_,_) -> ignore end, []}, ok = logger:add_handler_filter(h1,hf,HF), {error,{already_exist,hf}} = logger:add_handler_filter(h1,hf,HF), {error,{already_exist,hf}} = logger:add_handler_filter(h1,hf,{fun(Log,_) -> Log end, []}), ?LOG_INFO("hello",[]), ok = check_logged(mylevel,"hello",[],?MY_LOC(1)), ok = check_logged(error,"hello",[],?MY_LOC(2)), ok = logger:remove_logger_filter(lf), {error,{not_found,lf}} = logger:remove_logger_filter(lf), ?LOG_INFO("hello",[]), ok = check_logged(info,"hello",[],?MY_LOC(1)), ok = check_logged(info,"hello",[],?MY_LOC(2)), ?LOG_ERROR("hello",[]), ok = check_logged(mylevel,"hello",[],?MY_LOC(1)), ok = check_logged(error,"hello",[],?MY_LOC(2)), ok = logger:remove_handler_filter(h1,hf), {error,{not_found,hf}} = logger:remove_handler_filter(h1,hf), ?LOG_INFO("hello",[]), ok = check_logged(info,"hello",[],?MY_LOC(1)), ok = check_logged(info,"hello",[],?MY_LOC(2)), ?LOG_ERROR("hello",[]), ok = check_logged(error,"hello",[],?MY_LOC(1)), ok = check_logged(error,"hello",[],?MY_LOC(2)), ok. add_remove_filter(cleanup,_Config) -> logger:remove_logger_filter(lf), logger:remove_handler(h1), logger:remove_handler(h2), ok. change_config(_Config) -> %% Overwrite handler config - check that defaults are added ok = logger:add_handler(h1,?MODULE,#{level=>info,custom=>custom}), {ok,{?MODULE,#{level:=info,filter_default:=log,custom:=custom}}} = logger:get_handler_config(h1), register(callback_receiver,self()), ok = logger:set_handler_config(h1,#{filter_default=>stop}), [changing_config] = test_server:messages_get(), {ok,{?MODULE,#{level:=all,filter_default:=stop}=C2}} = logger:get_handler_config(h1), false = maps:is_key(custom,C2), {error,fail} = logger:set_handler_config(h1,#{conf_call=>fun() -> {error,fail} end}), {error,{attempting_syncronous_call_to_self,_}} = logger:set_handler_config( h1,#{conf_call=>fun() -> logger:set_handler_config(?MODULE,#{}) end}), ok = logger:set_handler_config( h1,#{conf_call=>fun() -> logger:set_module_level(?MODULE,debug) end}), {ok,{?MODULE,C2}} = logger:get_handler_config(h1), %% Change handler config: Single key {error,fail} = logger:set_handler_config(h1,conf_call,fun() -> {error,fail} end), ok = logger:set_handler_config(h1,custom,custom), [changing_config] = test_server:messages_get(), {ok,{?MODULE,#{custom:=custom}=C3}} = logger:get_handler_config(h1), C2 = maps:remove(custom,C3), %% Change handler config: Map ok = logger:update_handler_config(h1,#{custom=>new_custom}), [changing_config] = test_server:messages_get(), {ok,{_,C4}} = logger:get_handler_config(h1), C4 = C3#{custom:=new_custom}, %% Change logger config: Single key {ok,LConfig0} = logger:get_logger_config(), ok = logger:set_logger_config(level,warning), {ok,LConfig1} = logger:get_logger_config(), LConfig1 = LConfig0#{level:=warning}, %% Change logger config: Map ok = logger:update_logger_config(#{level=>error}), {ok,LConfig2} = logger:get_logger_config(), LConfig2 = LConfig1#{level:=error}, %% Overwrite logger config - check that defaults are added ok = logger:set_logger_config(#{filter_default=>stop}), {ok,#{level:=info,filters:=[],filter_default:=stop}=LC1} = logger:get_logger_config(), 3 = maps:size(LC1), %% Check that internal 'handlers' field has not been changed #{handlers:=HCs} = logger:i(), HIds1 = [Id || {Id,_,_} <- HCs], {ok,#{handlers:=HIds2}} = logger_config:get(?LOGGER_TABLE,logger), HIds1 = lists:sort(HIds2), %% Cleanup ok = logger:set_logger_config(LConfig0), [] = test_server:messages_get(), ok. change_config(cleanup,Config) -> logger:remove_handler(h1), LC = ?config(logger_config,Config), logger:set_logger_config(LC), ok. set_formatter(_Config) -> {error,{not_found,h1}}=logger:set_handler_config(h1,formatter,{?MODULE,[]}), ok = logger:add_handler(h1,?MODULE,#{level=>info,filter_default=>log}), ok = logger:set_handler_config(h1,formatter,{?MODULE,[]}), logger:info("hello",[]), receive {_Log,#{formatter:={?MODULE,[]}}} -> ok after 500 -> ct:fail({timeout,no_log,process_info(self(),messages)}) end, ok. set_formatter(cleanup,_Config) -> logger:remove_handler(h1), ok. log_no_levels(_Config) -> ok = logger:add_handler(h1,?MODULE,#{level=>all,filter_default=>log}), logger:notice(M1=?map_rep), ok = check_logged(notice,M1,#{}), Levels = [emergency,alert,critical,error,warning,notice,info,debug], ok = logger:set_logger_config(level,none), [logger:Level(#{Level=>rep}) || Level <- Levels], ok = check_no_log(), ok = logger:set_logger_config(level,all), M2 = ?map_rep, ?LOG_NOTICE(M2), ok = check_logged(notice,M2,#{}), ok = logger:set_module_level(?MODULE,none), ?LOG_EMERGENCY(?map_rep), ?LOG_ALERT(?map_rep), ?LOG_CRITICAL(?map_rep), ?LOG_ERROR(?map_rep), ?LOG_WARNING(?map_rep), ?LOG_NOTICE(?map_rep), ?LOG_INFO(?map_rep), ?LOG_DEBUG(?map_rep), ok = check_no_log(), ok = logger:unset_module_level(?MODULE), logger:notice(M3=?map_rep), ok = check_logged(notice,M3,#{}), ok = logger:set_handler_config(h1,level,none), [logger:Level(#{Level=>rep}) || Level <- Levels], ok = check_no_log(), ok. log_no_levels(cleanup,_Config) -> logger:remove_handler(h1), logger:set_logger_level(level,info), logger:unset_module_level(?MODULE), ok. log_all_levels_api(_Config) -> ok = logger:set_logger_config(level,all), ok = logger:add_handler(h1,?MODULE,#{level=>all,filter_default=>log}), test_api(emergency), test_api(alert), test_api(critical), test_api(error), test_api(warning), test_api(notice), test_api(info), test_api(debug), test_log_function(emergency), ok. log_all_levels_api(cleanup,_Config) -> logger:remove_handler(h1), logger:set_logger_config(level,info), ok. macros(_Config) -> ok = logger:add_handler(h1,?MODULE,#{level=>all,filter_default=>log}), test_macros(emergency), ok. macros(cleanup,_Config) -> logger:remove_handler(h1), logger:unset_module_level(?MODULE), ok. set_level(_Config) -> ok = logger:add_handler(h1,?MODULE,#{level=>all,filter_default=>log}), logger:debug(?map_rep), ok = check_no_log(), logger:info(M1=?map_rep), ok = check_logged(info,M1,#{}), ok = logger:set_logger_config(level,debug), logger:debug(M2=?map_rep), ok = check_logged(debug,M2,#{}), ok. set_level(cleanup,_Config) -> logger:remove_handler(h1), logger:set_logger_config(level,info), ok. set_module_level(_Config) -> [] = logger:get_module_level([?MODULE,other]), [] = logger:get_module_level(?MODULE), [] = logger:get_module_level(), ok = logger:add_handler(h1,?MODULE,#{level=>info,filter_default=>log}), {error,{invalid_level,bad}} = logger:set_module_level(?MODULE,bad), {error,{not_a_list_of_modules,{bad}}} = logger:set_module_level({bad},warning), ok = logger:set_module_level(?MODULE,warning), [{?MODULE,warning}] = logger:get_module_level([?MODULE,other]), [{?MODULE,warning}] = logger:get_module_level(?MODULE), [{?MODULE,warning}] = logger:get_module_level(), logger:info(?map_rep,?MY_LOC(0)), ok = check_no_log(), logger:warning(M1=?map_rep,?MY_LOC(0)), ok = check_logged(warning,M1,?MY_LOC(1)), ok = logger:set_module_level(?MODULE,info), [{?MODULE,info}] = logger:get_module_level([?MODULE,other]), [{?MODULE,info}] = logger:get_module_level(?MODULE), [{?MODULE,info}] = logger:get_module_level(), logger:info(M2=?map_rep,?MY_LOC(0)), ok = check_logged(info,M2,?MY_LOC(1)), {error,{not_a_list_of_modules,{bad}}} = logger:unset_module_level({bad}), ok = logger:unset_module_level(?MODULE), [] = logger:get_module_level([?MODULE,other]), [] = logger:get_module_level(?MODULE), [] = logger:get_module_level(), ok = logger:set_module_level([m1,m2,m3],info), [{m1,info},{m2,info},{m3,info}] = logger:get_module_level(), ok = logger:unset_module_level(m2), [{m1,info},{m3,info}] = logger:get_module_level(), ok = logger:unset_module_level(), [] = logger:get_module_level(), ok. set_module_level(cleanup,_Config) -> logger:remove_handler(h1), logger:unset_module_level(?MODULE), ok. cache_module_level(_Config) -> ok = logger:unset_module_level(?MODULE), [] = ets:lookup(logger,?MODULE), %dirty - add API in logger_config? ?LOG_INFO(?map_rep), %% Caching is done asynchronously, so wait a bit for the update timer:sleep(100), [_] = ets:lookup(logger,?MODULE), %dirty - add API in logger_config? ok = logger:unset_module_level(?MODULE), [] = ets:lookup(logger,?MODULE), %dirty - add API in logger_config? ok. cache_module_level(cleanup,_Config) -> logger:unset_module_level(?MODULE), ok. format_report(_Config) -> {"~ts",["string"]} = logger:format_report("string"), {"~tp",[term]} = logger:format_report(term), {"~tp",[[]]} = logger:format_report([]), {" ~tp: ~tp",[key,value]} = logger:format_report([{key,value}]), KeyVals = [{key1,value1},{key2,"value2"},{key3,[]}], KeyValRes = {" ~tp: ~tp\n ~tp: ~ts\n ~tp: ~tp", [key1,value1,key2,"value2",key3,[]]} = logger:format_report(KeyVals), KeyValRes = logger:format_report(maps:from_list(KeyVals)), KeyValRes = logger:format_otp_report(#{label=>{?MODULE,test},report=>KeyVals}), {" ~tp: ~tp\n ~tp: ~tp", [label,{?MODULE,test},report,KeyVals]} = logger:format_report(#{label=>{?MODULE,test},report=>KeyVals}), {" ~tp: ~tp\n ~tp",[key1,value1,term]} = logger:format_report([{key1,value1},term]), {" ~tp: ~tp\n ~tp",[key1,value1,[]]} = logger:format_report([{key1,value1},[]]), {"~tp",[[]]} = logger:format_report([[],[],[]]), ok. filter_failed(_Config) -> ok = logger:add_handler(h1,?MODULE,#{level=>info,filter_default=>log}), %% Logger filters {error,{invalid_filter,_}} = logger:add_logger_filter(lf,{fun(_) -> ok end,args}), ok = logger:add_logger_filter(lf,{fun(_,_) -> a=b end,args}), {ok,#{filters:=[_]}} = logger:get_logger_config(), ok = logger:info(M1=?map_rep), ok = check_logged(info,M1,#{}), {error,{not_found,lf}} = logger:remove_logger_filter(lf), ok = logger:add_logger_filter(lf,{fun(_,_) -> faulty_return end,args}), {ok,#{filters:=[_]}} = logger:get_logger_config(), ok = logger:info(M2=?map_rep), ok = check_logged(info,M2,#{}), {error,{not_found,lf}} = logger:remove_logger_filter(lf), %% Handler filters {error,{not_found,h0}} = logger:add_handler_filter(h0,hf,{fun(_,_) -> ignore end,args}), {error,{not_found,h0}} = logger:remove_handler_filter(h0,hf), {error,{invalid_filter,_}} = logger:add_handler_filter(h1,hf,{fun(_) -> ok end,args}), ok = logger:add_handler_filter(h1,hf,{fun(_,_) -> a=b end,args}), {ok,{?MODULE,#{filters:=[_]}}} = logger:get_handler_config(h1), ok = logger:info(M3=?map_rep), ok = check_logged(info,M3,#{}), {error,{not_found,hf}} = logger:remove_handler_filter(h1,hf), ok = logger:add_handler_filter(h1,hf,{fun(_,_) -> faulty_return end,args}), {ok,{?MODULE,#{filters:=[_]}}} = logger:get_handler_config(h1), ok = logger:info(M4=?map_rep), ok = check_logged(info,M4,#{}), {error,{not_found,hf}} = logger:remove_handler_filter(h1,hf), ok. filter_failed(cleanup,_Config) -> logger:remove_handler(h1), ok. handler_failed(_Config) -> register(callback_receiver,self()), {error,{invalid_id,1}} = logger:add_handler(1,?MODULE,#{}), {error,{invalid_module,"nomodule"}} = logger:add_handler(h1,"nomodule",#{}), {error,{invalid_handler_config,bad}} = logger:add_handler(h1,?MODULE,bad), {error,{invalid_filters,false}} = logger:add_handler(h1,?MODULE,#{filters=>false}), {error,{invalid_filter_default,true}} = logger:add_handler(h1,?MODULE,#{filter_default=>true}), {error,{invalid_formatter,[]}} = logger:add_handler(h1,?MODULE,#{formatter=>[]}), {error,{invalid_handler,_}} = logger:add_handler(h1,nomodule,#{filter_default=>log}), logger:info(?map_rep), check_no_log(), #{handlers:=H1} = logger:i(), false = lists:keymember(h1,1,H1), {error,{not_found,h1}} = logger:remove_handler(h1), ok = logger:add_handler(h2,?MODULE,#{filter_default=>log,log_call=>fun() -> a = b end}), {error,{already_exist,h2}} = logger:add_handler(h2,othermodule,#{}), [add] = test_server:messages_get(), logger:info(?map_rep), [remove] = test_server:messages_get(), #{handlers:=H2} = logger:i(), false = lists:keymember(h2,1,H2), {error,{not_found,h2}} = logger:remove_handler(h2), CallAddHandler = fun() -> logger:add_handler(h2,?MODULE,#{}) end, CrashHandler = fun() -> a = b end, KillHandler = fun() -> exit(self(), die) end, {error,{handler_not_added,{attempting_syncronous_call_to_self,_}}} = logger:add_handler(h1,?MODULE,#{add_call=>CallAddHandler}), {error,{handler_not_added,{callback_crashed,_}}} = logger:add_handler(h1,?MODULE,#{add_call=>CrashHandler}), {error,{handler_not_added,{logger_process_exited,_,die}}} = logger:add_handler(h1,?MODULE,#{add_call=>KillHandler}), check_no_log(), ok = logger:add_handler(h1,?MODULE,#{}), {error,{attempting_syncronous_call_to_self,_}} = logger:set_handler_config(h1,#{conf_call=>CallAddHandler}), {error,{callback_crashed,_}} = logger:set_handler_config(h1,#{conf_call=>CrashHandler}), {error,{logger_process_exited,_,die}} = logger:set_handler_config(h1,#{conf_call=>KillHandler}), {error,{attempting_syncronous_call_to_self,_}} = logger:set_handler_config(h1,conf_call,CallAddHandler), {error,{callback_crashed,_}} = logger:set_handler_config(h1,conf_call,CrashHandler), {error,{logger_process_exited,_,die}} = logger:set_handler_config(h1,conf_call,KillHandler), ok = logger:remove_handler(h1), [add,remove] = test_server:messages_get(), check_no_log(), ok = logger:add_handler(h1,?MODULE,#{rem_call=>CallAddHandler}), ok = logger:remove_handler(h1), ok = logger:add_handler(h1,?MODULE,#{rem_call=>CrashHandler}), ok = logger:remove_handler(h1), ok = logger:add_handler(h1,?MODULE,#{rem_call=>KillHandler}), ok = logger:remove_handler(h1), [add,add,add] = test_server:messages_get(), ok. handler_failed(cleanup,_Config) -> logger:remove_handler(h1), logger:remove_handler(h2), ok. config_sanity_check(_Config) -> %% Logger config {error,{invalid_filter_default,bad}} = logger:set_logger_config(filter_default,bad), {error,{invalid_level,bad}} = logger:set_logger_config(level,bad), {error,{invalid_filters,bad}} = logger:set_logger_config(filters,bad), {error,{invalid_filter,bad}} = logger:set_logger_config(filters,[bad]), {error,{invalid_filter,{_,_}}} = logger:set_logger_config(filters,[{id,bad}]), {error,{invalid_filter,{_,{_,_}}}} = logger:set_logger_config(filters,[{id,{bad,args}}]), {error,{invalid_filter,{_,{_,_}}}} = logger:set_logger_config(filters,[{id,{fun() -> ok end,args}}]), {error,{invalid_logger_config,{bad,bad}}} = logger:set_logger_config(bad,bad), %% Handler config {error,{not_found,h1}} = logger:set_handler_config(h1,a,b), ok = logger:add_handler(h1,?MODULE,#{}), {error,{invalid_filter_default,bad}} = logger:set_handler_config(h1,filter_default,bad), {error,{invalid_level,bad}} = logger:set_handler_config(h1,level,bad), {error,{invalid_filters,bad}} = logger:set_handler_config(h1,filters,bad), {error,{invalid_filter,bad}} = logger:set_handler_config(h1,filters,[bad]), {error,{invalid_filter,{_,_}}} = logger:set_handler_config(h1,filters,[{id,bad}]), {error,{invalid_filter,{_,{_,_}}}} = logger:set_handler_config(h1,filters,[{id,{bad,args}}]), {error,{invalid_filter,{_,{_,_}}}} = logger:set_handler_config(h1,filters,[{id,{fun() -> ok end,args}}]), {error,{invalid_formatter,bad}} = logger:set_handler_config(h1,formatter,bad), {error,{invalid_module,{bad}}} = logger:set_handler_config(h1,formatter,{{bad},cfg}), {error,{invalid_formatter_config,logger_formatter,bad}} = logger:set_handler_config(h1,formatter,{logger_formatter,bad}), {error,{invalid_formatter_config,logger_formatter,{bad,bad}}} = logger:set_handler_config(h1,formatter,{logger_formatter,#{bad=>bad}}), {error,{invalid_formatter_config,logger_formatter,{template,bad}}} = logger:set_handler_config(h1,formatter,{logger_formatter, #{template=>bad}}), {error,{invalid_formatter_template,logger_formatter,[1]}} = logger:set_handler_config(h1,formatter,{logger_formatter, #{template=>[1]}}), ok = logger:set_handler_config(h1,formatter,{logger_formatter, #{template=>[]}}), {error,{invalid_formatter_config,logger_formatter,{single_line,bad}}} = logger:set_handler_config(h1,formatter,{logger_formatter, #{single_line=>bad}}), ok = logger:set_handler_config(h1,formatter,{logger_formatter, #{single_line=>true}}), {error,{invalid_formatter_config,logger_formatter,{legacy_header,bad}}} = logger:set_handler_config(h1,formatter,{logger_formatter, #{legacy_header=>bad}}), ok = logger:set_handler_config(h1,formatter,{logger_formatter, #{legacy_header=>true}}), {error,{invalid_formatter_config,logger_formatter,{report_cb,bad}}} = logger:set_handler_config(h1,formatter,{logger_formatter, #{report_cb=>bad}}), ok = logger:set_handler_config(h1,formatter,{logger_formatter, #{report_cb=>fun(R) -> {"~p",[R]} end}}), {error,{invalid_formatter_config,logger_formatter,{chars_limit,bad}}} = logger:set_handler_config(h1,formatter,{logger_formatter, #{chars_limit=>bad}}), ok = logger:set_handler_config(h1,formatter,{logger_formatter, #{chars_limit=>unlimited}}), ok = logger:set_handler_config(h1,formatter,{logger_formatter, #{chars_limit=>4}}), {error,{invalid_formatter_config,logger_formatter,{depth,bad}}} = logger:set_handler_config(h1,formatter,{logger_formatter, #{depth=>bad}}), ok = logger:set_handler_config(h1,formatter,{logger_formatter, #{depth=>unlimited}}), ok = logger:set_handler_config(h1,formatter,{logger_formatter, #{depth=>4}}), {error,{invalid_formatter_config,logger_formatter,{max_size,bad}}} = logger:set_handler_config(h1,formatter,{logger_formatter, #{max_size=>bad}}), ok = logger:set_handler_config(h1,formatter,{logger_formatter, #{max_size=>unlimited}}), ok = logger:set_handler_config(h1,formatter,{logger_formatter, #{max_size=>4}}), ok = logger:set_handler_config(h1,formatter,{module,config}), {error,{callback_crashed,{error,{badmatch,3},[{?MODULE,check_config,1,_}]}}} = logger:set_handler_config(h1,formatter,{?MODULE,crash}), ok = logger:set_handler_config(h1,custom,custom), %% Old utc parameter is no longer allowed (replaced by time_offset) {error,{invalid_formatter_config,logger_formatter,{utc,true}}} = logger:set_handler_config(h1,formatter,{logger_formatter, #{utc=>true}}), {error,{invalid_formatter_config,logger_formatter,{time_offset,bad}}} = logger:set_handler_config(h1,formatter,{logger_formatter, #{time_offset=>bad}}), ok = logger:set_handler_config(h1,formatter,{logger_formatter, #{time_offset=>0}}), ok = logger:set_handler_config(h1,formatter,{logger_formatter, #{time_offset=>""}}), ok = logger:set_handler_config(h1,formatter,{logger_formatter, #{time_offset=>"Z"}}), ok = logger:set_handler_config(h1,formatter,{logger_formatter, #{time_offset=>"z"}}), ok = logger:set_handler_config(h1,formatter,{logger_formatter, #{time_offset=>"-0:0"}}), ok = logger:set_handler_config(h1,formatter,{logger_formatter, #{time_offset=>"+10:13"}}), {error,{invalid_formatter_config,logger_formatter,{time_offset,"+0"}}} = logger:set_handler_config(h1,formatter,{logger_formatter, #{time_offset=>"+0"}}), {error,{invalid_formatter_config,logger_formatter,{time_designator,bad}}} = logger:set_handler_config(h1,formatter,{logger_formatter, #{time_designator=>bad}}), {error,{invalid_formatter_config,logger_formatter,{time_designator,"s"}}} = logger:set_handler_config(h1,formatter,{logger_formatter, #{time_designator=>"s"}}), {error,{invalid_formatter_config,logger_formatter,{time_designator,0}}} = logger:set_handler_config(h1,formatter,{logger_formatter, #{time_designator=>0}}), ok = logger:set_handler_config(h1,formatter,{logger_formatter, #{time_designator=>$\s}}), ok. config_sanity_check(cleanup,_Config) -> logger:remove_handler(h1), ok. log_failed(_Config) -> ok = logger:add_handler(h1,?MODULE,#{level=>info,filter_default=>log}), {error,function_clause} = ?TRY(logger:log(bad,?map_rep)), {error,function_clause} = ?TRY(logger:log(info,?map_rep,bad)), {error,function_clause} = ?TRY(logger:log(info,fun() -> ?map_rep end,bad)), {error,function_clause} = ?TRY(logger:log(info,fun() -> ?map_rep end,bad,#{})), {error,function_clause} = ?TRY(logger:log(info,bad,bad,bad)), {error,function_clause} = ?TRY(logger:log(info,bad,bad,#{})), check_no_log(), ok = logger:log(info,M1=?str,#{}), check_logged(info,M1,#{}), ok = logger:log(info,M2=?map_rep,#{}), check_logged(info,M2,#{}), ok = logger:log(info,M3=?keyval_rep,#{}), check_logged(info,M3,#{}), %% Should we check report input more thoroughly? ok = logger:log(info,M4=?keyval_rep++[other,stuff,in,list],#{}), check_logged(info,M4,#{}), %% This might break a handler since it is assumed to be a format %% string and args, so it depends how the handler protects itself %% against something like io_lib:format("ok","ok") ok = logger:log(info,"ok","ok",#{}), check_logged(info,"ok","ok",#{}), ok. log_failed(cleanup,_Config) -> logger:remove_handler(h1), ok. emulator(_Config) -> ok = logger:add_handler(h1,?MODULE,#{level=>info,filter_default=>log, tc_proc=>self()}), Msg = "Error in process ~p on node ~p with exit value:~n~p~n", Error = {badmatch,4}, Stack = [{module, function, 2, []}], Pid = spawn(?MODULE, generate_error, [Error, Stack]), check_logged(error, Msg, [Pid, node(), {Error, Stack}], #{gl=>group_leader(), error_logger=>#{tag=>error,emulator=>true}}), ok. emulator(cleanup, _Config) -> logger:remove_handler(h1), ok. generate_error(Error, Stack) -> erlang:raise(error, Error, Stack). via_logger_process(Config) -> ok = logger:add_handler(h1,?MODULE,#{level=>info,filter_default=>log, tc_proc=>self()}), %% Explicitly send a message to the logger process %% This is used by code_server, erl_prim_loader, init, prim_file, ... Msg = ?str, logger ! {log,error,Msg,[],#{}}, check_logged(error, Msg, [], #{}), case os:type() of {win32,_} -> %% Skip this part on windows - cant change file mode" ok; _ -> %% This should trigger the same thing from erl_prim_loader Dir = filename:join(?config(priv_dir,Config),"dummydir"), ok = file:make_dir(Dir), ok = file:change_mode(Dir,8#0222), error = erl_prim_loader:list_dir(Dir), check_logged(error, #{report=>"File operation error: eacces. Target: " ++ Dir ++". Function: list_dir. "}, #{pid=>self(), gl=>group_leader(), error_logger=>#{tag=>error_report, type=>std_error}}), ok end. via_logger_process(cleanup, Config) -> Dir = filename:join(?config(priv_dir,Config),"dummydir"), _ = file:change_mode(Dir,8#0664), _ = file:del_dir(Dir), logger:remove_handler(h1), ok. other_node(_Config) -> ok = logger:add_handler(h1,?MODULE,#{level=>info,filter_default=>log, tc_proc=>self()}), {ok,Node} = test_server:start_node(?FUNCTION_NAME,slave,[]), rpc:call(Node,logger,error,[Msg=?str,#{}]), check_logged(error,Msg,#{}), ok. other_node(cleanup,_Config) -> Nodes = nodes(), [test_server:stop_node(Node) || Node <- Nodes], logger:remove_handler(h1), ok. compare_levels(_Config) -> Levels = [emergency,alert,critical,error,warning,notice,info,debug], ok = compare(Levels), {error,badarg} = ?TRY(logger:compare_levels(bad,bad)), {error,badarg} = ?TRY(logger:compare_levels({bad},info)), {error,badarg} = ?TRY(logger:compare_levels(info,"bad")), ok. compare([L|Rest]) -> eq = logger:compare_levels(L,L), [gt = logger:compare_levels(L,L1) || L1 <- Rest], [lt = logger:compare_levels(L1,L) || L1 <- Rest], compare(Rest); compare([]) -> ok. process_metadata(_Config) -> undefined = logger:get_process_metadata(), {error,badarg} = ?TRY(logger:set_process_metadata(bad)), ok = logger:add_handler(h1,?MODULE,#{level=>info,filter_default=>log}), Time = erlang:system_time(microsecond), ProcMeta = #{time=>Time,line=>0,custom=>proc}, ok = logger:set_process_metadata(ProcMeta), S1 = ?str, ?LOG_INFO(S1,#{custom=>macro}), check_logged(info,S1,#{time=>Time,line=>0,custom=>macro}), Time2 = erlang:system_time(microsecond), S2 = ?str, ?LOG_INFO(S2,#{time=>Time2,line=>1,custom=>macro}), check_logged(info,S2,#{time=>Time2,line=>1,custom=>macro}), logger:info(S3=?str,#{custom=>func}), check_logged(info,S3,#{time=>Time,line=>0,custom=>func}), ProcMeta = logger:get_process_metadata(), ok = logger:update_process_metadata(#{custom=>changed,custom2=>added}), Expected = ProcMeta#{custom:=changed,custom2=>added}, Expected = logger:get_process_metadata(), ok = logger:unset_process_metadata(), undefined = logger:get_process_metadata(), ok. process_metadata(cleanup,_Config) -> logger:remove_handler(h1), ok. %%%----------------------------------------------------------------- %%% Internal check_logged(Level,Format,Args,Meta) -> do_check_logged(Level,{Format,Args},Meta). check_logged(Level,Msg,Meta) when ?IS_REPORT(Msg) -> do_check_logged(Level,{report,Msg},Meta); check_logged(Level,Msg,Meta) when ?IS_STRING(Msg) -> do_check_logged(Level,{string,Msg},Meta). do_check_logged(Level,Msg0,Meta0) -> receive {#{level:=Level,msg:=Msg,meta:=Meta},_} -> check_msg(Msg0,Msg), check_maps(Meta0,Meta,meta) after 500 -> ct:fail({timeout,no_log,process_info(self(),messages)}) end. check_no_log() -> receive X -> ct:fail({got_unexpected_log,X}) after 500 -> ok end. check_msg(Msg,Msg) -> ok; check_msg({report,Expected},{report,Got}) when is_map(Expected), is_map(Got) -> check_maps(Expected,Got,msg); check_msg(Expected,Got) -> ct:fail({unexpected,msg,Expected,Got}). check_maps(Expected,Got,What) -> case maps:merge(Got,Expected) of Got -> ok; _ -> ct:fail({unexpected,What,Expected,Got}) end. %% Handler adding_handler(#{add_call:=Fun}) -> Fun(); adding_handler(Config) -> maybe_send(add), {ok,Config}. removing_handler(#{rem_call:=Fun}) -> Fun(); removing_handler(_Config) -> maybe_send(remove), ok. changing_config(_Old,#{conf_call:=Fun}) -> Fun(); changing_config(_Old,Config) -> maybe_send(changing_config), {ok,Config}. maybe_send(Msg) -> case whereis(callback_receiver) of undefined -> ok; Pid -> Pid ! Msg end. log(_Log,#{log_call:=Fun}) -> Fun(); log(Log,Config) -> TcProc = maps:get(tc_proc,Config,self()), TcProc ! {Log,Config}, ok. test_api(Level) -> logger:Level(#{Level=>rep}), ok = check_logged(Level,#{Level=>rep},#{}), logger:Level(#{Level=>rep},#{my=>meta}), ok = check_logged(Level,#{Level=>rep},#{my=>meta}), logger:Level("~w: ~w",[Level,fa]), ok = check_logged(Level,"~w: ~w",[Level,fa],#{}), logger:Level("~w: ~w ~w",[Level,fa,meta],#{my=>meta}), ok = check_logged(Level,"~w: ~w ~w",[Level,fa,meta],#{my=>meta}), logger:Level(fun(x) -> {"~w: ~w ~w",[Level,fun_to_fa,meta]} end,x, #{my=>meta}), ok = check_logged(Level,"~w: ~w ~w",[Level,fun_to_fa,meta],#{my=>meta}), logger:Level(fun(x) -> #{Level=>fun_to_r,meta=>true} end,x, #{my=>meta}), ok = check_logged(Level,#{Level=>fun_to_r,meta=>true},#{my=>meta}), logger:Level(fun(x) -> <<"fun_to_s">> end,x,#{}), ok = check_logged(Level,<<"fun_to_s">>,#{}), logger:Level(F1=fun(x) -> {fun_to_bad} end,x,#{}), ok = check_logged(Level,"LAZY_FUN ERROR: ~tp; Returned: ~tp", [{F1,x},{fun_to_bad}],#{}), logger:Level(F2=fun(x) -> erlang:error(fun_that_crashes) end,x,#{}), ok = check_logged(Level,"LAZY_FUN CRASH: ~tp; Reason: ~tp", [{F2,x},{error,fun_that_crashes}],#{}), ok. test_log_function(Level) -> logger:log(Level,#{Level=>rep}), ok = check_logged(Level,#{Level=>rep},#{}), logger:log(Level,#{Level=>rep},#{my=>meta}), ok = check_logged(Level,#{Level=>rep},#{my=>meta}), logger:log(Level,"~w: ~w",[Level,fa]), ok = check_logged(Level,"~w: ~w",[Level,fa],#{}), logger:log(Level,"~w: ~w ~w",[Level,fa,meta],#{my=>meta}), ok = check_logged(Level,"~w: ~w ~w",[Level,fa,meta],#{my=>meta}), logger:log(Level,fun(x) -> {"~w: ~w ~w",[Level,fun_to_fa,meta]} end, x, #{my=>meta}), ok = check_logged(Level,"~w: ~w ~w",[Level,fun_to_fa,meta],#{my=>meta}), logger:log(Level,fun(x) -> #{Level=>fun_to_r,meta=>true} end, x, #{my=>meta}), ok = check_logged(Level,#{Level=>fun_to_r,meta=>true},#{my=>meta}), logger:log(Level,fun(x) -> <<"fun_to_s">> end,x,#{}), ok = check_logged(Level,<<"fun_to_s">>,#{}), logger:log(Level,F1=fun(x) -> {fun_to_bad} end,x,#{}), ok = check_logged(Level,"LAZY_FUN ERROR: ~tp; Returned: ~tp", [{F1,x},{fun_to_bad}],#{}), logger:log(Level,F2=fun(x) -> erlang:error(fun_that_crashes) end,x,#{}), ok = check_logged(Level,"LAZY_FUN CRASH: ~tp; Reason: ~tp", [{F2,x},{error,fun_that_crashes}],#{}), ok. test_macros(emergency=Level) -> ?LOG_EMERGENCY(#{Level=>rep}), ok = check_logged(Level,#{Level=>rep},?MY_LOC(1)), ?LOG_EMERGENCY(#{Level=>rep},#{my=>meta}), ok = check_logged(Level,#{Level=>rep},(?MY_LOC(1))#{my=>meta}), ?LOG_EMERGENCY("~w: ~w",[Level,fa]), ok = check_logged(Level,"~w: ~w",[Level,fa],?MY_LOC(1)), ?LOG_EMERGENCY("~w: ~w ~w",[Level,fa,meta],#{my=>meta}), ok = check_logged(Level,"~w: ~w ~w",[Level,fa,meta],(?MY_LOC(1))#{my=>meta}), ?LOG_EMERGENCY(fun(x) -> {"~w: ~w ~w",[Level,fun_to_fa,meta]} end, x, #{my=>meta}), ok = check_logged(Level,"~w: ~w ~w",[Level,fun_to_fa,meta], (?MY_LOC(3))#{my=>meta}), ?LOG_EMERGENCY(fun(x) -> #{Level=>fun_to_r,meta=>true} end, x, #{my=>meta}), ok = check_logged(Level,#{Level=>fun_to_r,meta=>true}, (?MY_LOC(2))#{my=>meta}), ?LOG_EMERGENCY(fun(x) -> <<"fun_to_s">> end,x,#{}), ok = check_logged(Level,<<"fun_to_s">>,?MY_LOC(1)), F1=fun(x) -> {fun_to_bad} end, ?LOG_EMERGENCY(F1,x,#{}), ok = check_logged(Level,"LAZY_FUN ERROR: ~tp; Returned: ~tp", [{F1,x},{fun_to_bad}],#{}), F2=fun(x) -> erlang:error(fun_that_crashes) end, ?LOG_EMERGENCY(F2,x,#{}), ok = check_logged(Level,"LAZY_FUN CRASH: ~tp; Reason: ~tp", [{F2,x},{error,fun_that_crashes}],#{}), ok. %%%----------------------------------------------------------------- %%% Called by macro ?TRY(X) my_try(Fun) -> try Fun() catch C:R -> {C,R} end. check_config(crash) -> erlang:error({badmatch,3}); check_config(_) -> ok.