Specs

add_handler(HandlerId, Module, Config) -> ok | {error, term()}
               when HandlerId :: handler_id(), Module :: module(), Config :: handler_config().

Add a handler with the given configuration.

HandlerId is a unique identifier which must be used in all subsequent calls referring to this handler.

Specs

add_handler_filter(HandlerId, FilterId, Filter) -> ok | {error, term()}
                      when HandlerId :: handler_id(), FilterId :: filter_id(), Filter :: filter().

Add a filter to the specified handler.

The filter fun is called with the log event as the first parameter, and the specified filter_args() as the second parameter.

The return value of the fun specifies if a log event is to be discarded or forwarded to the handler callback:

log_event()

The filter passed. The next handler filter, if any, is applied. If no more filters exist for this handler, the log event is forwarded to the handler callback.

stop

The filter did not pass, and the log event is immediately discarded.

ignore

The filter has no knowledge of the log event. The next handler filter, if any, is applied. If no more filters exist for this handler, the value of the filter_default configuration parameter for the handler specifies if the log event shall be discarded or forwarded to the handler callback.

See section Filters in the User's Guide for more information about filters.

Some built-in filters exist. These are defined in logger_filters(3).

Specs

add_handlers(Application) -> ok | {error, term()} when Application :: atom();
            (HandlerConfig) -> ok | {error, term()} when HandlerConfig :: [config_handler()].

Reads the application configuration parameter logger and calls add_handlers/1 with its contents.

Specs

add_handlers(Application) -> ok | {error, term()} when Application :: atom();
            (HandlerConfig) -> ok | {error, term()} when HandlerConfig :: [config_handler()].

This function should be used by custom Logger handlers to make configuration consistent no matter which handler the system uses. Normal usage is to add a call to logger:add_handlers/1 just after the processes that the handler needs are started, and pass the application's logger configuration as the argument. For example:

-behaviour(application).
start(_, []) ->
    case supervisor:start_link({local, my_sup}, my_sup, []) of
        {ok, Pid} ->
            ok = logger:add_handlers(my_app),
            {ok, Pid, []};
        Error -> Error
     end.

This reads the logger configuration parameter from the my_app application and starts the configured handlers. The contents of the configuration use the same rules as the logger handler configuration.

If the handler is meant to replace the default handler, the Kernel's default handler have to be disabled before the new handler is added. A sys.config file that disables the Kernel handler and adds a custom handler could look like this:

[{kernel,
  [{logger,
    %% Disable the default Kernel handler
    [{handler, default, undefined}]}]},
 {my_app,
  [{logger,
    %% Enable this handler as the default
    [{handler, default, my_handler, #{}}]}]}].
         

Specs

add_primary_filter(FilterId, Filter) -> ok | {error, term()}
                      when FilterId :: filter_id(), Filter :: filter().

Add a primary filter to Logger.

The filter fun is called with the log event as the first parameter, and the specified filter_args() as the second parameter.

The return value of the fun specifies if a log event is to be discarded or forwarded to the handlers:

log_event()

The filter passed. The next primary filter, if any, is applied. If no more primary filters exist, the log event is forwarded to the handler part of Logger, where handler filters are applied.

stop

The filter did not pass, and the log event is immediately discarded.

ignore

The filter has no knowledge of the log event. The next primary filter, if any, is applied. If no more primary filters exist, the value of the primary filter_default configuration parameter specifies if the log event shall be discarded or forwarded to the handler part.

See section Filters in the User's Guide for more information about filters.

Some built-in filters exist. These are defined in logger_filters(3).

Equivalent to log(alert,...).

Specs

compare_levels(Level1, Level2) -> eq | gt | lt
                  when Level1 :: level() | all | none, Level2 :: level() | all | none.

Compare the severity of two log levels. Returns gt if Level1 is more severe than Level2, lt if Level1 is less severe, and eq if the levels are equal.

Equivalent to log(critical,...).

Equivalent to log(debug,...).

Equivalent to log(emergency,...).

Equivalent to log(error,...).

Specs

format_report(Report) -> FormatArgs when Report :: report(), FormatArgs :: {io:format(), [term()]}.

Convert a log message on report form to {Format, Args}. This is the default report callback used by logger_formatter(3) when no custom report callback is found. See section Log Message in the Kernel User's Guide for information about report callbacks and valid forms of log messages.

The function produces lines of Key: Value from key-value lists. Strings are printed with ~ts and other terms with ~tp.

If Report is a map, it is converted to a key-value list before formatting as such.

Specs

get_config() ->
              #{primary => primary_config(),
                handlers => [handler_config()],
                proxy => olp_config(),
                module_levels => [{module(), level() | all | none}]}.

Look up all current Logger configuration, including primary, handler, and proxy configuration, and module level settings.

Specs

get_handler_config() -> [Config] when Config :: handler_config().

Look up the current configuration for all handlers.

Specs

get_handler_config(HandlerId) -> {ok, Config} | {error, term()}
                      when HandlerId :: handler_id(), Config :: handler_config().

Look up the current configuration for the given handler.

Specs

get_handler_ids() -> [HandlerId] when HandlerId :: handler_id().

Look up the identities for all installed handlers.

Specs

get_module_level() -> [{Module, Level}] when Module :: module(), Level :: level() | all | none.

Look up all current module levels. Returns a list containing one {Module,Level} element for each module for which the module level was previously set with set_module_level/2.

Specs

get_module_level(Modules) -> [{Module, Level}]
                    when
                        Modules :: [Module] | Module,
                        Module :: module(),
                        Level :: level() | all | none.

Look up the current level for the given modules. Returns a list containing one {Module,Level} element for each of the given modules for which the module level was previously set with set_module_level/2.

Specs

get_primary_config() -> Config when Config :: primary_config().

Look up the current primary configuration for Logger.

Specs

get_process_metadata() -> Meta | undefined when Meta :: metadata().

Retrieve data set with set_process_metadata/1 or update_process_metadata/1.

Specs

get_proxy_config() -> Config when Config :: olp_config().

Look up the current configuration for the Logger proxy.

For more information about the proxy, see section Logger Proxy in the Kernel User's Guide.

Specs

i() -> ok.

Pretty print the Logger configuration.

Specs

i(What) -> ok when What :: primary | handlers | proxy | modules | handler_id().

Equivalent to log(info,...).

Specs

log(Level, StringOrReport) -> ok
       when Level :: level(), StringOrReport :: unicode:chardata() | report().

Create a log event at the given log level, with the given message to be logged and metadata. Examples:

%% A plain string
logger:log(info, "Hello World").
%% A plain string with metadata
logger:log(debug, "Hello World", #{ meta => data }).
%% A format string with arguments
logger:log(warning, "The roof is on ~ts",[Cause]).
%% A report
logger:log(warning, #{ what => roof, cause => Cause }).
        

The message and metadata can either be given directly in the arguments, or returned from a fun. Passing a fun instead of the message/metadata directly is useful in scenarios when the message/metadata is very expensive to compute. This is because the fun is only evaluted when the message/metadata is actually needed, which may be not at all if the log event is not to be logged. Examples:

%% A plain string with expensive metadata
logger:info(fun([]) -> {"Hello World", #{ meta => expensive() }} end,[]).
%% An expensive report
logger:debug(fun(What) -> #{ what => What, cause => expensive() } end,roof).
%% A plain string with expensive metadata and normal metadata
logger:debug(fun([]) -> {"Hello World", #{ meta => expensive() }} end,[],
             #{ meta => data }).
        

When metadata is given both as an argument and returned from the fun they are merged. If equal keys exists the values are taken from the metadata returned by the fun.

Specs

log(Level, StringOrReport, Metadata) -> ok
       when
           Level :: level(),
           StringOrReport :: unicode:chardata() | report(),
           Metadata :: metadata();
   (Level, Format, Args) -> ok when Level :: level(), Format :: io:format(), Args :: [term()];
   (Level, Fun, FunArgs) -> ok when Level :: level(), Fun :: msg_fun(), FunArgs :: term().

Specs

log(Level, Format, Args, Metadata) -> ok
       when Level :: level(), Format :: io:format(), Args :: [term()], Metadata :: metadata();
   (Level, Fun, FunArgs, Metadata) -> ok
       when Level :: level(), Fun :: msg_fun(), FunArgs :: term(), Metadata :: metadata().

Equivalent to log(notice,...).

Specs

remove_handler(HandlerId) -> ok | {error, term()} when HandlerId :: handler_id().

Remove the handler identified by HandlerId.

Specs

remove_handler_filter(HandlerId, FilterId) -> ok | {error, term()}
                         when HandlerId :: handler_id(), FilterId :: filter_id().

Remove the filter identified by FilterId from the handler identified by HandlerId.

Specs

remove_primary_filter(FilterId) -> ok | {error, term()} when FilterId :: filter_id().

Remove the primary filter identified by FilterId from Logger.

Specs

set_application_level(Application, Level) -> ok | {error, not_loaded}
                         when Application :: atom(), Level :: level() | all | none.

Set the log level for all the modules of the specified application.

This function is a convenience function that calls logger:set_module_level/2 for each module associated with an application.

Specs

set_handler_config(HandlerId, Config) -> ok | {error, term()}
                      when HandlerId :: handler_id(), Config :: handler_config().

Set configuration data for the specified handler. This overwrites the current handler configuration.

To modify the existing configuration, use update_handler_config/2, or, if a more complex merge is needed, read the current configuration with get_handler_config/1 , then do the merge before writing the new configuration back with this function.

If a key is removed compared to the current configuration, and the key is known by Logger, the default value is used. If it is a custom key, then it is up to the handler implementation if the value is removed or a default value is inserted.

Specs

set_handler_config(HandlerId, level, Level) -> Return
                      when
                          HandlerId :: handler_id(),
                          Level :: level() | all | none,
                          Return :: ok | {error, term()};
                  (HandlerId, filter_default, FilterDefault) -> Return
                      when
                          HandlerId :: handler_id(),
                          FilterDefault :: log | stop,
                          Return :: ok | {error, term()};
                  (HandlerId, filters, Filters) -> Return
                      when
                          HandlerId :: handler_id(),
                          Filters :: [{filter_id(), filter()}],
                          Return :: ok | {error, term()};
                  (HandlerId, formatter, Formatter) -> Return
                      when
                          HandlerId :: handler_id(),
                          Formatter :: {module(), formatter_config()},
                          Return :: ok | {error, term()};
                  (HandlerId, config, Config) -> Return
                      when
                          HandlerId :: handler_id(),
                          Config :: term(),
                          Return :: ok | {error, term()}.

Add or update configuration data for the specified handler. If the given Key already exists, its associated value will be changed to the given value. If it does not exist, it will be added.

If the value is incomplete, which for example can be the case for the config key, it is up to the handler implementation how the unspecified parts are set. For all handlers in the Kernel application, unspecified data for the config key is set to default values. To update only specified data, and keep the existing configuration for the rest, use update_handler_config/3.

See the definition of the handler_config() type for more information about the different parameters.

Specs

set_module_level(Modules, Level) -> ok | {error, term()}
                    when Modules :: [module()] | module(), Level :: level() | all | none.

Set the log level for the specified modules.

The log level for a module overrides the primary log level of Logger for log events originating from the module in question. Notice, however, that it does not override the level configuration for any handler.

For example: Assume that the primary log level for Logger is info, and there is one handler, h1, with level info and one handler, h2, with level debug.

With this configuration, no debug messages will be logged, since they are all stopped by the primary log level.

If the level for mymodule is now set to debug, then debug events from this module will be logged by the handler h2, but not by handler h1.

Debug events from other modules are still not logged.

To change the primary log level for Logger, use set_primary_config(level, Level).

To change the log level for a handler, use set_handler_config(HandlerId, level, Level) .

Specs

set_primary_config(Config) -> ok | {error, term()} when Config :: primary_config().

Set primary configuration data for Logger. This overwrites the current configuration.

To modify the existing configuration, use update_primary_config/1, or, if a more complex merge is needed, read the current configuration with get_primary_config/0 , then do the merge before writing the new configuration back with this function.

If a key is removed compared to the current configuration, the default value is used.

Specs

set_primary_config(level, Level) -> ok | {error, term()} when Level :: level() | all | none;
                  (filter_default, FilterDefault) -> ok | {error, term()}
                      when FilterDefault :: log | stop;
                  (filters, Filters) -> ok | {error, term()}
                      when Filters :: [{filter_id(), filter()}];
                  (metadata, Meta) -> ok | {error, term()} when Meta :: metadata().

Add or update primary configuration data for Logger. If the given Key already exists, its associated value will be changed to the given value. If it does not exist, it will be added.

Specs

set_process_metadata(Meta) -> ok when Meta :: metadata().

Set metadata which Logger shall automatically insert in all log events produced on the current process.

Location data produced by the log macros, and/or metadata given as argument to the log call (API function or macro), are merged with the process metadata. If the same keys occur, values from the metadata argument to the log call overwrite values from the process metadata, which in turn overwrite values from the location data.

Subsequent calls to this function overwrites previous data set. To update existing data instead of overwriting it, see update_process_metadata/1.

Specs

set_proxy_config(Config) -> ok | {error, term()} when Config :: olp_config().

Set configuration data for the Logger proxy. This overwrites the current proxy configuration. Keys that are not specified in the Config map gets default values.

To modify the existing configuration, use update_proxy_config/1, or, if a more complex merge is needed, read the current configuration with get_proxy_config/0 , then do the merge before writing the new configuration back with this function.

For more information about the proxy, see section Logger Proxy in the Kernel User's Guide.

Specs

timestamp() -> timestamp().

Return a timestamp that can be inserted as the time field in the meta data for a log event. It is produced with os:system_time(microsecond).

Notice that Logger automatically inserts a timestamp in the meta data unless it already exists. This function is exported for the rare case when the timestamp must be taken at a different point in time than when the log event is issued.

Specs

unset_application_level(Application) -> ok | {error, {not_loaded, Application}}
                           when Application :: atom().

Unset the log level for all the modules of the specified application.

This function is a utility function that calls logger:unset_module_level/2 for each module associated with an application.

Specs

unset_module_level() -> ok.

Remove module specific log settings. After this, the primary log level is used for all modules.

Specs

unset_module_level(Modules) -> ok when Modules :: [module()] | module().

Remove module specific log settings. After this, the primary log level is used for the specified modules.

Specs

unset_process_metadata() -> ok.

Delete data set with set_process_metadata/1 or update_process_metadata/1.

Specs

update_formatter_config(HandlerId, FormatterConfig) -> ok | {error, term()}
                           when HandlerId :: handler_id(), FormatterConfig :: formatter_config().

Update the formatter configuration for the specified handler.

The new configuration is merged with the existing formatter configuration.

To overwrite the existing configuration without any merge, use

set_handler_config(HandlerId, formatter,
	      {FormatterModule, FormatterConfig}).

Specs

update_formatter_config(HandlerId, Key, Value) -> ok | {error, term()}
                           when HandlerId :: handler_id(), Key :: atom(), Value :: term().

Update the formatter configuration for the specified handler.

This is equivalent to

update_formatter_config(HandlerId, #{Key => Value})

Specs

update_handler_config(HandlerId, Config) -> ok | {error, term()}
                         when HandlerId :: handler_id(), Config :: handler_config().

Update configuration data for the specified handler. This function behaves as if it was implemented as follows:

{ok, {_, Old}} = logger:get_handler_config(HandlerId),
logger:set_handler_config(HandlerId, maps:merge(Old, Config)).
	

To overwrite the existing configuration without any merge, use set_handler_config/2 .

Specs

update_handler_config(HandlerId, level, Level) -> Return
                         when
                             HandlerId :: handler_id(),
                             Level :: level() | all | none,
                             Return :: ok | {error, term()};
                     (HandlerId, filter_default, FilterDefault) -> Return
                         when
                             HandlerId :: handler_id(),
                             FilterDefault :: log | stop,
                             Return :: ok | {error, term()};
                     (HandlerId, filters, Filters) -> Return
                         when
                             HandlerId :: handler_id(),
                             Filters :: [{filter_id(), filter()}],
                             Return :: ok | {error, term()};
                     (HandlerId, formatter, Formatter) -> Return
                         when
                             HandlerId :: handler_id(),
                             Formatter :: {module(), formatter_config()},
                             Return :: ok | {error, term()};
                     (HandlerId, config, Config) -> Return
                         when
                             HandlerId :: handler_id(),
                             Config :: term(),
                             Return :: ok | {error, term()}.

Add or update configuration data for the specified handler. If the given Key already exists, its associated value will be changed to the given value. If it does not exist, it will be added.

If the value is incomplete, which for example can be the case for the config key, it is up to the handler implementation how the unspecified parts are set. For all handlers in the Kernel application, unspecified data for the config key is not changed. To reset unspecified data to default values, use set_handler_config/3.

See the definition of the handler_config() type for more information about the different parameters.

Specs

update_primary_config(Config) -> ok | {error, term()} when Config :: primary_config().

Update primary configuration data for Logger. This function behaves as if it was implemented as follows:

Old = logger:get_primary_config(),
logger:set_primary_config(maps:merge(Old, Config)).
	

To overwrite the existing configuration without any merge, use set_primary_config/1 .

Specs

update_process_metadata(Meta) -> ok when Meta :: metadata().

Set or update metadata to use when logging from current process

If process metadata exists for the current process, this function behaves as if it was implemented as follows:

logger:set_process_metadata(maps:merge(logger:get_process_metadata(), Meta)).
	

If no process metadata exists, the function behaves as set_process_metadata/1 .

Specs

update_proxy_config(Config) -> ok | {error, term()} when Config :: olp_config().

Update configuration data for the Logger proxy. This function behaves as if it was implemented as follows:

Old = logger:get_proxy_config(),
logger:set_proxy_config(maps:merge(Old, Config)).
	

To overwrite the existing configuration without any merge, use set_proxy_config/1 .

For more information about the proxy, see section Logger Proxy in the Kernel User's Guide.

Equivalent to log(warning,...).