[logger] Change concept of 'global' configuration to 'primary' configuration

Function names changed:

get/set/update_logger_config -> get/set/update_primary_config
add/remove_logger_filter -> add/remove_primary_filter

5 files changed, 60 insertions, 60 deletions

diff --git a/lib/kernel/src/logger.erl b/lib/kernel/src/logger.erl
index f8661ea228..9f96a537bc 100644
--- a/lib/kernel/src/logger.erl
+++ b/lib/kernel/src/logger.erl
@@ -35,16 +35,16 @@
 
 %% Configuration
 -export([add_handler/3, remove_handler/1,
-         add_logger_filter/2, add_handler_filter/3,
-         remove_logger_filter/1, remove_handler_filter/2,
+         add_primary_filter/2, add_handler_filter/3,
+         remove_primary_filter/1, remove_handler_filter/2,
          set_module_level/2,
          unset_module_level/1, unset_module_level/0,
          get_module_level/0, get_module_level/1,
-         set_logger_config/1, set_logger_config/2,
+         set_primary_config/1, set_primary_config/2,
          set_handler_config/2, set_handler_config/3,
-         update_logger_config/1, update_handler_config/2,
+         update_primary_config/1, update_handler_config/2,
          update_formatter_config/2, update_formatter_config/3,
-         get_logger_config/0, get_handler_config/1,
+         get_primary_config/0, get_handler_config/1,
          add_handlers/1]).
 
 %% Private configuration
@@ -310,11 +310,11 @@ internal_log(Level,Term) when is_atom(Level) ->
 
 %%%-----------------------------------------------------------------
 %%% Configuration
--spec add_logger_filter(FilterId,Filter) -> ok | {error,term()} when
+-spec add_primary_filter(FilterId,Filter) -> ok | {error,term()} when
       FilterId :: filter_id(),
       Filter :: filter().
-add_logger_filter(FilterId,Filter) ->
-    logger_server:add_filter(logger,{FilterId,Filter}).
+add_primary_filter(FilterId,Filter) ->
+    logger_server:add_filter(primary,{FilterId,Filter}).
 
 -spec add_handler_filter(HandlerId,FilterId,Filter) -> ok | {error,term()} when
       HandlerId :: handler_id(),
@@ -324,10 +324,10 @@ add_handler_filter(HandlerId,FilterId,Filter) ->
     logger_server:add_filter(HandlerId,{FilterId,Filter}).
 
 
--spec remove_logger_filter(FilterId) -> ok | {error,term()} when
+-spec remove_primary_filter(FilterId) -> ok | {error,term()} when
       FilterId :: filter_id().
-remove_logger_filter(FilterId) ->
-    logger_server:remove_filter(logger,FilterId).
+remove_primary_filter(FilterId) ->
+    logger_server:remove_filter(primary,FilterId).
 
 -spec remove_handler_filter(HandlerId,FilterId) -> ok | {error,term()} when
       HandlerId :: handler_id(),
@@ -347,16 +347,16 @@ add_handler(HandlerId,Module,Config) ->
 remove_handler(HandlerId) ->
     logger_server:remove_handler(HandlerId).
 
--spec set_logger_config(Key,Value) -> ok | {error,term()} when
+-spec set_primary_config(Key,Value) -> ok | {error,term()} when
       Key :: atom(),
       Value :: term().
-set_logger_config(Key,Value) ->
-    logger_server:set_config(logger,Key,Value).
+set_primary_config(Key,Value) ->
+    logger_server:set_config(primary,Key,Value).
 
--spec set_logger_config(Config) -> ok | {error,term()} when
+-spec set_primary_config(Config) -> ok | {error,term()} when
       Config :: config().
-set_logger_config(Config) ->
-    logger_server:set_config(logger,Config).
+set_primary_config(Config) ->
+    logger_server:set_config(primary,Config).
 
 -spec set_handler_config(HandlerId,Key,Value) -> ok | {error,term()} when
       HandlerId :: handler_id(),
@@ -371,10 +371,10 @@ set_handler_config(HandlerId,Key,Value) ->
 set_handler_config(HandlerId,Config) ->
     logger_server:set_config(HandlerId,Config).
 
--spec update_logger_config(Config) -> ok | {error,term()} when
+-spec update_primary_config(Config) -> ok | {error,term()} when
       Config :: config().
-update_logger_config(Config) ->
-    logger_server:update_config(logger,Config).
+update_primary_config(Config) ->
+    logger_server:update_config(primary,Config).
 
 -spec update_handler_config(HandlerId,Config) -> ok | {error,term()} when
       HandlerId :: handler_id(),
@@ -382,10 +382,10 @@ update_logger_config(Config) ->
 update_handler_config(HandlerId,Config) ->
     logger_server:update_config(HandlerId,Config).
 
--spec get_logger_config() -> {ok,Config} when
+-spec get_primary_config() -> {ok,Config} when
       Config :: config().
-get_logger_config() ->
-    {ok,Config} = logger_config:get(?LOGGER_TABLE,logger),
+get_primary_config() ->
+    {ok,Config} = logger_config:get(?LOGGER_TABLE,primary),
     {ok,maps:remove(handlers,Config)}.
 
 -spec get_handler_config(HandlerId) -> {ok,{Module,Config}} | {error,term()} when
@@ -492,13 +492,13 @@ unset_process_metadata() ->
     _ = erase(?LOGGER_META_KEY),
     ok.
 
--spec i() -> #{logger=>config(),
+-spec i() -> #{primary=>config(),
                handlers=>[{handler_id(),module(),config()}],
                module_levels=>[{module(),level() | all | none}]}.
 i() ->
     i(term).
 
--spec i(term) -> #{logger=>config(),
+-spec i(term) -> #{primary=>config(),
                    handlers=>[{handler_id(),module(),config()}],
                    module_levels=>[{module(),level() | all | none}]};
        (print) -> ok;
@@ -506,7 +506,7 @@ i() ->
 i(_Action = print) ->
     io:put_chars(i(string));
 i(_Action = string) ->
-    #{logger := #{level := Level,
+    #{primary := #{level := Level,
                   filters := Filters,
                   filter_default := FilterDefault},
       handlers := HandlerConfigs,
@@ -522,8 +522,8 @@ i(_Action = string) ->
      print_module_levels(Modules)
     ];
 i(_Action = term) ->
-    {Logger, Handlers, Modules} = logger_config:get(?LOGGER_TABLE),
-    #{logger=>maps:remove(handlers,Logger),
+    {Primary, Handlers, Modules} = logger_config:get(?LOGGER_TABLE),
+    #{primary=>maps:remove(handlers,Primary),
       handlers=>lists:keysort(1,Handlers),
       module_levels=>lists:keysort(1,Modules)}.
 
@@ -576,13 +576,13 @@ print_module_levels(ModuleLevels) ->
 %% tree is started.
 internal_init_logger() ->
     try
-        ok = logger:set_logger_config(level, get_logger_level()),
-        ok = logger:set_logger_config(filter_default, get_logger_filter_default()),
+        ok = logger:set_primary_config(level, get_logger_level()),
+        ok = logger:set_primary_config(filter_default, get_primary_filter_default()),
 
-        [case logger:add_logger_filter(Id, Filter) of
+        [case logger:add_primary_filter(Id, Filter) of
              ok -> ok;
              {error, Reason} -> throw(Reason)
-         end || {Id, Filter} <- get_logger_filters()],
+         end || {Id, Filter} <- get_primary_filters()],
 
         _ = [[case logger:set_module_level(Module, Level) of
                   ok -> ok;
@@ -703,7 +703,7 @@ get_logger_level() ->
             throw({logger_level, Level})
     end.
 
-get_logger_filter_default() ->
+get_primary_filter_default() ->
     case lists:keyfind(filters,1,get_logger_env()) of
         {filters,Default,_} ->
             Default;
@@ -711,7 +711,7 @@ get_logger_filter_default() ->
             log
     end.
 
-get_logger_filters() ->
+get_primary_filters() ->
     lists:foldl(
       fun({filters, _, Filters}, _Acc) ->
               Filters;
diff --git a/lib/kernel/src/logger_backend.erl b/lib/kernel/src/logger_backend.erl
index b3cf7d67dd..a73b681e0d 100644
--- a/lib/kernel/src/logger_backend.erl
+++ b/lib/kernel/src/logger_backend.erl
@@ -28,9 +28,9 @@
 %%%-----------------------------------------------------------------
 %%% The default logger backend
 log_allowed(Log, Tid) ->
-    {ok,Config} = logger_config:get(Tid,logger),
+    {ok,Config} = logger_config:get(Tid,primary),
     Filters = maps:get(filters,Config,[]),
-    case apply_filters(logger,Log,Filters,Config) of
+    case apply_filters(primary,Log,Filters,Config) of
         stop ->
             ok;
         Log1 ->
diff --git a/lib/kernel/src/logger_config.erl b/lib/kernel/src/logger_config.erl
index 113c8140cf..7b2148d034 100644
--- a/lib/kernel/src/logger_config.erl
+++ b/lib/kernel/src/logger_config.erl
@@ -54,7 +54,7 @@ allow(Tid,Level,Module) ->
     end.
 
 allow(Tid,Level) ->
-    GlobalLevelInt = ets:lookup_element(Tid,?LOGGER_KEY,2),
+    GlobalLevelInt = ets:lookup_element(Tid,?PRIMARY_KEY,2),
     level_to_int(Level) =< GlobalLevelInt.
 
 exist(Tid,What) ->
@@ -71,7 +71,7 @@ get(Tid,What) ->
     end.
 
 get(Tid,What,Level) ->
-    MS = [{{table_key(What),'$1','$2'}, % logger config
+    MS = [{{table_key(What),'$1','$2'}, % primary config
            [{'>=','$1',level_to_int(Level)}],
            ['$2']},
           {{table_key(What),'$1','$2','$3'}, % handler config
@@ -94,7 +94,7 @@ set(Tid,What,Config) ->
     %% Should do this only if the level has actually changed. Possibly
     %% overwrite instead of delete?
     case What of
-        logger ->
+        primary ->
             _ = ets:select_delete(Tid,[{{'_',{'$1',cached}},
                                         [{'=/=','$1',LevelInt}],
                                         [true]}]),
@@ -125,16 +125,16 @@ get_module_level(Tid) ->
     lists:sort([{M,int_to_level(L)} || {M,L} <- Modules]).
 
 cache_module_level(Tid,Module) ->
-    GlobalLevelInt = ets:lookup_element(Tid,?LOGGER_KEY,2),
+    GlobalLevelInt = ets:lookup_element(Tid,?PRIMARY_KEY,2),
     ets:insert_new(Tid,{Module,{GlobalLevelInt,cached}}),
     ok.
 
 get(Tid) ->
-    {ok,Logger} = get(Tid,logger),
+    {ok,Primary} = get(Tid,primary),
     HMS = [{{table_key('$1'),'_','$2','$3'},[],[{{'$1','$3','$2'}}]}],
     Handlers = ets:select(Tid,HMS),
     Modules = get_module_level(Tid),
-    {Logger,Handlers,Modules}.
+    {Primary,Handlers,Modules}.
 
 level_to_int(none) -> ?LOG_NONE;
 level_to_int(emergency) -> ?EMERGENCY;
@@ -161,5 +161,5 @@ int_to_level(?LOG_ALL) -> all.
 %%%-----------------------------------------------------------------
 %%% Internal
 
-table_key(logger) -> ?LOGGER_KEY;
+table_key(primary) -> ?PRIMARY_KEY;
 table_key(HandlerId) -> {?HANDLER_KEY,HandlerId}.
diff --git a/lib/kernel/src/logger_internal.hrl b/lib/kernel/src/logger_internal.hrl
index a0962cb8e0..8941409a25 100644
--- a/lib/kernel/src/logger_internal.hrl
+++ b/lib/kernel/src/logger_internal.hrl
@@ -19,7 +19,7 @@
 %%
 -include_lib("kernel/include/logger.hrl").
 -define(LOGGER_TABLE,logger).
--define(LOGGER_KEY,'$logger_config$').
+-define(PRIMARY_KEY,'$primary_config$').
 -define(HANDLER_KEY,'$handler_config$').
 -define(LOGGER_META_KEY,'$logger_metadata$').
 -define(STANDARD_HANDLER, default).
diff --git a/lib/kernel/src/logger_server.erl b/lib/kernel/src/logger_server.erl
index adbb2bc009..c7d386ab82 100644
--- a/lib/kernel/src/logger_server.erl
+++ b/lib/kernel/src/logger_server.erl
@@ -78,7 +78,7 @@ remove_filter(Owner,FilterId) ->
 set_module_level(Modules,Level) when is_list(Modules) ->
     case lists:all(fun(M) -> is_atom(M) end,Modules) of
         true ->
-            case sanity_check(logger,level,Level) of
+            case sanity_check(primary,level,Level) of
                 ok -> call({set_module_level,Modules,Level});
                 Error -> Error
             end;
@@ -138,9 +138,9 @@ update_formatter_config(_HandlerId, FormatterConfig) ->
 init([]) ->
     process_flag(trap_exit, true),
     Tid = logger_config:new(?LOGGER_TABLE),
-    LoggerConfig = maps:merge(default_config(logger),
+    PrimaryConfig = maps:merge(default_config(primary),
                               #{handlers=>[simple]}),
-    logger_config:create(Tid,logger,LoggerConfig),
+    logger_config:create(Tid,primary,PrimaryConfig),
     SimpleConfig0 = maps:merge(default_config(simple),
                                #{filter_default=>stop,
                                  filters=>?DEFAULT_HANDLER_FILTERS}),
@@ -166,9 +166,9 @@ handle_call({add_handler,Id,Module,HConfig}, From, #state{tid=Tid}=State) ->
                       case erlang:function_exported(Module, log, 2) of
                           true ->
                               logger_config:create(Tid,Id,Module,HConfig1),
-                              {ok,Config} = do_get_config(Tid,logger),
+                              {ok,Config} = do_get_config(Tid,primary),
                               Handlers = maps:get(handlers,Config,[]),
-                              do_set_config(Tid,logger,
+                              do_set_config(Tid,primary,
                                             Config#{handlers=>[Id|Handlers]});
                           false ->
                               {error,{invalid_handler,
@@ -182,7 +182,7 @@ handle_call({add_handler,Id,Module,HConfig}, From, #state{tid=Tid}=State) ->
 handle_call({remove_handler,HandlerId}, From, #state{tid=Tid}=State) ->
     case logger_config:get(Tid,HandlerId) of
         {ok,{Module,HConfig}} ->
-            {ok,Config} = do_get_config(Tid,logger),
+            {ok,Config} = do_get_config(Tid,primary),
             Handlers0 = maps:get(handlers,Config,[]),
             Handlers = lists:delete(HandlerId,Handlers0),
             call_h_async(
@@ -191,7 +191,7 @@ handle_call({remove_handler,HandlerId}, From, #state{tid=Tid}=State) ->
                       call_h(Module,removing_handler,[HConfig],ok)
               end,
               fun(_Res) ->
-                      do_set_config(Tid,logger,Config#{handlers=>Handlers}),
+                      do_set_config(Tid,primary,Config#{handlers=>Handlers}),
                       logger_config:delete(Tid,HandlerId),
                       ok
               end,From,State);
@@ -215,9 +215,9 @@ handle_call({update_config,Id,NewConfig}, From, #state{tid=Tid}=State) ->
         Error ->
             {reply,Error,State}
     end;
-handle_call({set_config,logger,Config}, _From, #state{tid=Tid}=State) ->
-    {ok,#{handlers:=Handlers}} = logger_config:get(Tid,logger),
-    Reply = do_set_config(Tid,logger,Config#{handlers=>Handlers}),
+handle_call({set_config,primary,Config}, _From, #state{tid=Tid}=State) ->
+    {ok,#{handlers:=Handlers}} = logger_config:get(Tid,primary),
+    Reply = do_set_config(Tid,primary,Config#{handlers=>Handlers}),
     {reply,Reply,State};
 handle_call({set_config,HandlerId,Config}, From, #state{tid=Tid}=State) ->
     case logger_config:get(Tid,HandlerId) of
@@ -282,7 +282,7 @@ handle_info({Ref,_Reply},State) when is_reference(Ref) ->
 handle_info({'DOWN',_Ref,_Proc,_Pid,_Reason} = Down,State) ->
     call_h_reply(Down,State);
 handle_info(Unexpected,State) when element(1,Unexpected) == 'EXIT' ->
-    %% The simple logger will send an 'EXIT' message when it is replaced
+    %% The simple handler will send an 'EXIT' message when it is replaced
     %% We may as well ignore all 'EXIT' messages that we get
     ?LOG_INTERNAL(debug,
                   [{logger,got_unexpected_message},
@@ -355,7 +355,7 @@ do_set_config(Tid,Id,Config) ->
     logger_config:set(Tid,Id,Config),
     ok.
 
-default_config(logger) ->
+default_config(primary) ->
     #{level=>info,
       filters=>[],
       filter_default=>log};
@@ -381,8 +381,8 @@ sanity_check_1(Owner,Config) when is_list(Config) ->
     catch throw:Error -> {error,Error}
     end.
 
-get_type(logger) ->
-    logger;
+get_type(primary) ->
+    primary;
 get_type(Id) ->
     check_id(Id),
     handler.
@@ -399,8 +399,8 @@ check_config(Owner,[{filter_default,FD}|Config]) ->
 check_config(handler,[{formatter,Formatter}|Config]) ->
     check_formatter(Formatter),
     check_config(handler,Config);
-check_config(logger,[C|_]) ->
-    throw({invalid_logger_config,C});
+check_config(primary,[C|_]) ->
+    throw({invalid_primary_config,C});
 check_config(handler,[{_,_}|Config]) ->
     %% Arbitrary config elements are allowed for handlers
     check_config(handler,Config);