--- name: "error_logger" section: "3erl" platform: "linux" package: "erlang-manpages" version: "1:25.2.3+dfsg-1+deb12u4" release: "Debian 12 (Bookworm)" platforms: ["linux"] url: "https://new.carta.tech/error_logger" --- # error\_logger(3erl) Erlang error logger. ## NAME error\_logger - Erlang error logger. ## DESCRIPTION **Note:** In Erlang/OTP 21.0, a new API for logging was added. The old *error\_logger* module can still be used by legacy code, but log events are redirected to the new Logger API. New code should use the Logger API directly. *error\_logger* is no longer started by default, but is automatically started when an event handler is added with *error\_logger:add\_report\_handler/1,2*. The *error\_logger* module is then also added as a handler to the new logger. See *[logger(3erl)](/logger/3erl.md)* and the Logging chapter in the User's Guide for more information. The Erlang *error logger* is an event manager (see OTP Design Principles and *[gen\_event(3erl)](/gen_event/3erl.md)*), registered as *error\_logger*. Error logger is no longer started by default, but is automatically started when an event handler is added with *add\_report\_handler/1,2*. The *error\_logger* module is then also added as a handler to the new logger, causing log events to be forwarded from logger to error logger, and consequently to all installed error logger event handlers. User-defined event handlers can be added to handle application-specific events. Existing event handlers provided by STDLIB and SASL are still available, but are no longer used by OTP. Warning events were introduced in Erlang/OTP R9C and are enabled by default as from Erlang/OTP 18.0. To retain backwards compatibility with existing user-defined event handlers, the warning events can be tagged as *errors* or *info* using command-line flag *+W \*, thus showing up as *ERROR REPORT* or *INFO REPORT* in the logs. ## DATA TYPES ``` report() = [{Tag :: term(), Data :: term()} | term()] | string() | term() ``` ## EXPORTS ``` add_report_handler(Handler) -> any() ``` ``` add_report_handler(Handler, Args) -> Result ``` Types: Handler = module()\ Args = gen\_event:handler\_args()\ Result = gen\_event:add\_handler\_ret()\ Adds a new event handler to the error logger. The event handler must be implemented as a *gen\_event* callback module, see *[gen\_event(3erl)](/gen_event/3erl.md)*. *Handler* is typically the name of the callback module and *Args* is an optional term (defaults to \[\]) passed to the initialization callback function *Handler:init/1*. The function returns *ok* if successful. The event handler must be able to handle the events in this module, see section Events. The first time this function is called, *error\_logger* is added as a Logger handler, and the *error\_logger* process is started. ``` delete_report_handler(Handler) -> Result ``` Types: Handler = module()\ Result = gen\_event:del\_handler\_ret()\ Deletes an event handler from the error logger by calling *gen\_event:delete\_handler(error\_logger, Handler, \[\])*, see *[gen\_event(3erl)](/gen_event/3erl.md)*. If no more event handlers exist after the deletion, *error\_logger* is removed as a Logger handler, and the *error\_logger* process is stopped. ``` error_msg(Format) -> ok ``` ``` error_msg(Format, Data) -> ok ``` ``` format(Format, Data) -> ok ``` Types: Format = string()\ Data = list()\ Log a standard error event. The *Format* and *Data* arguments are the same as the arguments of *io:format/2* in STDLIB. Error logger forwards the event to Logger, including metadata that allows backwards compatibility with legacy error logger event handlers. The event is handled by the default Logger handler. These functions are kept for backwards compatibility and must not be used by new code. Use the *?LOG\_ERROR* macro or *logger:error/1,2,3* instead. *Example:* ``` 1> error_logger:error_msg("An error occurred in ~p", [a_module]). =ERROR REPORT==== 22-May-2018::11:18:43.376917 === An error occurred in a_module ok ``` **Warning:** If the Unicode translation modifier (*t*) is used in the format string, all event handlers must ensure that the formatted output is correctly encoded for the I/O device. ``` error_report(Report) -> ok ``` Types: Report = report()\ Log a standard error event. Error logger forwards the event to Logger, including metadata that allows backwards compatibility with legacy error logger event handlers. The event is handled by the default Logger handler. This functions is kept for backwards compatibility and must not be used by new code. Use the *?LOG\_ERROR* macro or *logger:error/1,2,3* instead. *Example:* ``` 2> error_logger:error_report([{tag1,data1},a_term,{tag2,data}]). =ERROR REPORT==== 22-May-2018::11:24:23.699306 === tag1: data1 a_term tag2: data ok 3> error_logger:error_report("Serious error in my module"). =ERROR REPORT==== 22-May-2018::11:24:45.972445 === Serious error in my module ok ``` ``` error_report(Type, Report) -> ok ``` Types: Type = term()\ Report = report()\ Log a user-defined error event. Error logger forwards the event to Logger, including metadata that allows backwards compatibility with legacy error logger event handlers. Error logger also adds a *domain* field with value *\[Type\]* to this event's metadata, causing the filters of the default Logger handler to discard the event. A different Logger handler, or an error logger event handler, must be added to handle this event. It is recommended that *Report* follows the same structure as for *error\_report/1*. This functions is kept for backwards compatibility and must not be used by new code. Use the *?LOG\_ERROR* macro or *logger:error/1,2,3* instead. ``` get_format_depth() -> unlimited | integer() >= 1 ``` Returns *max(10, Depth)*, where *Depth* is the value of *error\_logger\_format\_depth* in the Kernel application, if Depth is an integer. Otherwise, *unlimited* is returned. **Note:** The *error\_logger\_format\_depth* variable is deprecated since the Logger API was introduced in Erlang/OTP 21.0. The variable, and this function, are kept for backwards compatibility since they still might be used by legacy report handlers. ``` info_msg(Format) -> ok ``` ``` info_msg(Format, Data) -> ok ``` Types: Format = string()\ Data = list()\ Log a standard information event. The *Format* and *Data* arguments are the same as the arguments of *io:format/2* in STDLIB. Error logger forwards the event to Logger, including metadata that allows backwards compatibility with legacy error logger event handlers. The event is handled by the default Logger handler. These functions are kept for backwards compatibility and must not be used by new code. Use the *?LOG\_INFO* macro or *logger:info/1,2,3* instead. *Example:* ``` 1> error_logger:info_msg("Something happened in ~p", [a_module]). =INFO REPORT==== 22-May-2018::12:03:32.612462 === Something happened in a_module ok ``` **Warning:** If the Unicode translation modifier (*t*) is used in the format string, all event handlers must ensure that the formatted output is correctly encoded for the I/O device. ``` info_report(Report) -> ok ``` Types: Report = report()\ Log a standard information event. Error logger forwards the event to Logger, including metadata that allows backwards compatibility with legacy error logger event handlers. The event is handled by the default Logger handler. This functions is kept for backwards compatibility and must not be used by new code. Use the *?LOG\_INFO* macro or *logger:info/1,2,3* instead. *Example:* ``` 2> error_logger:info_report([{tag1,data1},a_term,{tag2,data}]). =INFO REPORT==== 22-May-2018::12:06:35.994440 === tag1: data1 a_term tag2: data ok 3> error_logger:info_report("Something strange happened"). =INFO REPORT==== 22-May-2018::12:06:49.066872 === Something strange happened ok ``` ``` info_report(Type, Report) -> ok ``` Types: Type = any()\ Report = report()\ Log a user-defined information event. Error logger forwards the event to Logger, including metadata that allows backwards compatibility with legacy error logger event handlers. Error logger also adds a *domain* field with value *\[Type\]* to this event's metadata, causing the filters of the default Logger handler to discard the event. A different Logger handler, or an error logger event handler, must be added to handle this event. It is recommended that *Report* follows the same structure as for *info\_report/1*. This functions is kept for backwards compatibility and must not be used by new code. Use the *?LOG\_INFO* macro or *logger:info/1,2,3* instead. ``` logfile(Request :: {open, Filename}) -> ok | {error, OpenReason} ``` ``` logfile(Request :: close) -> ok | {error, CloseReason} ``` ``` logfile(Request :: filename) -> Filename | {error, FilenameReason} ``` Types: Filename = file:name()\ OpenReason = allready\_have\_logfile \| open\_error()\ CloseReason = module\_not\_found\ FilenameReason = no\_log\_file\ ``` open_error() = file:posix() | badarg | system_limit ``` Enables or disables printout of standard events to a file. This is done by adding or deleting the *error\_logger\_file\_h* event handler, and thus indirectly adding *error\_logger* as a Logger handler. Notice that this function does not manipulate the Logger configuration directly, meaning that if the default Logger handler is already logging to a file, this function can potentially cause logging to a second file. This function is useful as a shortcut during development and testing, but must not be used in a production system. See section Logging in the Kernel User's Guide, and the *[logger(3erl)](/logger/3erl.md)* manual page for information about how to configure Logger for live systems. *Request* is one of the following: - ***{open, Filename}*:** Opens log file *Filename*. Returns *ok* if successful, or *{error, allready\_have\_logfile}* if logging to file is already enabled, or an error tuple if another error occurred (for example, if *Filename* cannot be opened). The file is opened with encoding UTF-8. - ***close*:** Closes the current log file. Returns *ok*, or *{error, module\_not\_found}*. - ***filename*:** Returns the name of the log file *Filename*, or *{error, no\_log\_file}* if logging to file is not enabled. ``` tty(Flag) -> ok ``` Types: Flag = boolean()\ Enables (*Flag == true*) or disables (*Flag == false*) printout of standard events to the terminal. This is done by manipulating the Logger configuration. The function is useful as a shortcut during development and testing, but must not be used in a production system. See section Logging in the Kernel User's Guide, and the *[logger(3erl)](/logger/3erl.md)* manual page for information about how to configure Logger for live systems. ``` warning_map() -> Tag ``` Types: Tag = error \| warning \| info\ Returns the current mapping for warning events. Events sent using *warning\_msg/1,2* or *warning\_report/1,2* are tagged as errors, warnings (default), or info, depending on the value of command-line flag *+W*. *Example:* ``` os$ erl Erlang (BEAM) emulator version 5.4.8 [hipe] [threads:0] [kernel-poll] Eshell V5.4.8 (abort with ^G) 1> error_logger:warning_map(). warning 2> error_logger:warning_msg("Warnings tagged as: ~p~n", [warning]). =WARNING REPORT==== 11-Aug-2005::15:31:55 === Warnings tagged as: warning ok 3> User switch command --> q os$ erl +W e Erlang (BEAM) emulator version 5.4.8 [hipe] [threads:0] [kernel-poll] Eshell V5.4.8 (abort with ^G) 1> error_logger:warning_map(). error 2> error_logger:warning_msg("Warnings tagged as: ~p~n", [error]). =ERROR REPORT==== 11-Aug-2005::15:31:23 === Warnings tagged as: error ok ``` ``` warning_msg(Format) -> ok ``` ``` warning_msg(Format, Data) -> ok ``` Types: Format = string()\ Data = list()\ Log a standard warning event. The *Format* and *Data* arguments are the same as the arguments of *io:format/2* in STDLIB. Error logger forwards the event to Logger, including metadata that allows backwards compatibility with legacy error logger event handlers. The event is handled by the default Logger handler. The log level can be changed to error or info, see *warning\_map/0*. These functions are kept for backwards compatibility and must not be used by new code. Use the *?LOG\_WARNING* macro or *logger:warning/1,2,3* instead. **Warning:** If the Unicode translation modifier (*t*) is used in the format string, all event handlers must ensure that the formatted output is correctly encoded for the I/O device. ``` warning_report(Report) -> ok ``` Types: Report = report()\ Log a standard warning event. Error logger forwards the event to Logger, including metadata that allows backwards compatibility with legacy error logger event handlers. The event is handled by the default Logger handler. The log level can be changed to error or info, see *warning\_map/0*. This functions is kept for backwards compatibility and must not be used by new code. Use the *?LOG\_WARNING* macro or *logger:warning/1,2,3* instead. ``` warning_report(Type, Report) -> ok ``` Types: Type = any()\ Report = report()\ Log a user-defined warning event. Error logger forwards the event to Logger, including metadata that allows backwards compatibility with legacy error logger event handlers. Error logger also adds a *domain* field with value *\[Type\]* to this event's metadata, causing the filters of the default Logger handler to discard the event. A different Logger handler, or an error logger event handler, must be added to handle this event. The log level can be changed to error or info, see *warning\_map/0*. It is recommended that *Report* follows the same structure as for *warning\_report/1*. This functions is kept for backwards compatibility and must not be used by new code. Use the *?LOG\_WARNING* macro or *logger:warning/1,2,3* instead. ## EVENTS All event handlers added to the error logger must handle the following events. *Gleader* is the group leader pid of the process that sent the event, and *Pid* is the process that sent the event. - ***{error, Gleader, {Pid, Format, Data}}*:** Generated when *error\_msg/1,2* or *format* is called. - ***{error\_report, Gleader, {Pid, std\_error, Report}}*:** Generated when *error\_report/1* is called. - ***{error\_report, Gleader, {Pid, Type, Report}}*:** Generated when *error\_report/2* is called. - ***{warning\_msg, Gleader, {Pid, Format, Data}}*:** Generated when *warning\_msg/1,2* is called if warnings are set to be tagged as warnings. - ***{warning\_report, Gleader, {Pid, std\_warning, Report}}*:** Generated when *warning\_report/1* is called if warnings are set to be tagged as warnings. - ***{warning\_report, Gleader, {Pid, Type, Report}}*:** Generated when *warning\_report/2* is called if warnings are set to be tagged as warnings. - ***{info\_msg, Gleader, {Pid, Format, Data}}*:** Generated when *info\_msg/1,2* is called. - ***{info\_report, Gleader, {Pid, std\_info, Report}}*:** Generated when *info\_report/1* is called. - ***{info\_report, Gleader, {Pid, Type, Report}}*:** Generated when *info\_report/2* is called. Notice that some system-internal events can also be received. Therefore a catch-all clause last in the definition of the event handler callback function *Module:handle\_event/2* is necessary. This also applies for *Module:handle\_info/2*, as the event handler must also take care of some system-internal messages. ## SEE ALSO *[gen\_event(3erl)](/gen_event/3erl.md)*, *[logger(3erl)](/logger/3erl.md)*, *[log\_mf\_h(3erl)](/log_mf_h/3erl.md)*, *[kernel(7)](/kernel/7.md)*, *[sasl(7)](/sasl/7.md)*