A logger for Elixir applications.

This application is mostly a wrapper around Erlang's :logger functionality, to provide message translation and formatting to Elixir terms.

Overall, you will find that Logger:

• Provides all 7 syslog levels (although debug, info, warning, and error are the most commonly used).

• Supports both message-based and structural logging.

• Integrate with Erlang's :logger and support custom filters and handlers.

• Formats and truncates messages on the client to avoid clogging Logger handlers.

• Provides multiple forms of overload protection:

  • keeps track of its message queue and switches to sync mode to apply back pressure or even drop messages
  • limits the number of logs emitted defaulting to 500 per second
  • optionally allows to terminate and restart it if the message queue length or memory thresholds are exceeded

• Allows overriding the logging level for a specific module, application or process.

Logging is useful for tracking when an event of interest happens in your system. For example, it may be helpful to log whenever a user is deleted.

def delete_user(user) do
  Logger.info("Deleting user from the system: #{inspect(user)}")
  # ...
end

The Logger.info/2 macro emits the provided message at the :info level. Note the arguments given to info/2 will only be evaluated if a message is logged. For instance, if the Logger level is set to :warning, :info messages are never logged and therefore the arguments given above won't even be executed.

There are additional macros for other levels.

Logger also allows log commands to be removed altogether via the :compile_time_purge_matching option (see below).

For dynamically logging messages, see bare_log/3. But note that bare_log/3 always evaluates its arguments (unless the argument is an anonymous function).

Levels

The supported levels, ordered by importance, are:

• :emergency - when system is unusable, panics
• :alert - for alerts, actions that must be taken immediately, ex. corrupted database
• :critical - for critical conditions
• :error - for errors
• :warning - for warnings
• :notice - for normal, but significant, messages
• :info - for information of any kind
• :debug - for debug-related messages

For example, :info takes precedence over :debug. If your log level is set to :info, then all :info, :notice and above will be passed to handlers. If your log level is set to :alert, only :alert and :emergency will be printed.

Message

Logger can be used for logging both unstructured and structured data.

Unstructured data is a string or a list of strings:

Logger.info("hello world!")
Logger.info(["hello ", "world!"])

Structured data, also known as reports, are keyword lists and maps:

Logger.info([new_user: user.id, account_type: :admin])
Logger.info(%{new_user: user.id, account_type: :admin})

Log functions also accept a zero-arity anonymous function as a message:

Logger.info(fn -> "hello world!" end)

The anonymous function can return a message or a tuple containing the message and additional metadata (to be described in the next section).

In all cases, the arguments given to the Logger macros are only evaluated if required by the current log level. The exception is the bare_log/3 function, which is the raw mechanism for logging.

Metadata

Whenever a message is logged, additional information can be given via metadata. Each log operation, such as Logger.info/2, allows metadata to be given as an argument.

Furthermore, metadata can be set per process with Logger.metadata/1.

Some metadata, however, may be added automatically by Logger whenever possible. Those are:

• :application - the current application

• :mfa - the current module, function and arity

• :file - the current file

• :line - the current line

• :pid - the current process identifier

• :initial_call - the initial call that started the process

• :registered_name - the process registered name as an atom

• :process_label - (available from Erlang/OTP 27+) an arbitrary term which can be added to a process with Process.set_label/1 for debugging purposes

• :domain - a list of domains for the logged message. For example, all Elixir reports default to [:elixir]. Erlang reports may start with [:otp] or [:sasl]

• :crash_reason - a two-element tuple with the throw/error/exit reason as first argument and the stacktrace as second. A throw will always be {:nocatch, term}. An error is always an Exception struct. All other entries are exits. The default formatter ignores this metadata by default but it can be useful to certain handlers, such as the ones that report errors to third-party services

There are two special metadata keys, :module and :function, which extract the relevant bits from :mfa.

The metadata keys above may not always be available. The :mfa, :file, :line, and similar metadata are automatically included when using Logger macros, but not when using Logger.bare_log/3. Other metadata, such as :crash_reason, :initial_call, and :registered_name are available only inside behaviours such as GenServer, Supervisor, and others.

It is also possible to pass metadata on a particular Logger invocation. For example, you might wish to include a custom :error_code metadata in your logs:

Logger.error("We have a problem", [error_code: :pc_load_letter])

By default, no metadata is logged. We will learn how to enable that over the next sections.

Configuration

Logger supports a wide range of configurations.

This configuration is split in three categories:

• Boot configuration - this configuration is read when logger starts and configures how Elixir hooks into Erlang's own logger

• Compile configuration - this must be set before your code is compiled

• Runtime configuration - can be set before the :logger application is started, but may be changed during runtime

Boot configuration

When Logger starts, it configures the :default log handler from Erlang to translate and format Elixir terms. As a developer, you are able to customize the default handler, the default formatter, and many other options.

The following configuration must be set via config files (such as config/config.exs), under the :logger key, before your application is started:

• :default_formatter - a keyword list which configures the default formatter used by the default handler. See Logger.Formatter for the full list of configuration.

• :default_handler - this option configures the default handler used for logging. The default handler is a :logger_std_h instance which also supports file logging and log rotation. You can set it to false to disable the default logging altogether. See the examples below for more information.

• :handle_otp_reports - if Erlang/OTP message should be logged. Defaults to true.

• :handle_sasl_reports - if supervisor, crash, and progress reports should be logged. Defaults to false. This option only has an effect if :handle_otp_reports is true.

• :metadata - key-value pairs of global primary metadata to be included in all log messages. Defaults to []. The default formatter writes to standard out and therefore cannot print all metadata. See Logger.Formatter's documentation for more information.

For example, to configure Logger to redirect all Erlang messages using a config/config.exs file:

config :logger,
  handle_otp_reports: true,
  handle_sasl_reports: true

To configure the default formatter, for example, to use a different format and include some metadata:

config :logger, :default_formatter,
  format: "[$level] $message $metadata\n",
  metadata: [:error_code, :file]

Or to configure default handler, for instance, to log into a file with built-in support for log rotation and compression:

config :logger, :default_handler,
  config: [
    file: ~c"system.log",
    filesync_repeat_interval: 5000,
    file_check: 5000,
    max_no_bytes: 10_000_000,
    max_no_files: 5,
    compress_on_rotate: true
  ]

You can find a complete reference on all handler options on Erlang/OTP docs. Here is Elixir's default configuration for the default handler:

[
  # Do not log messages from other nodes
  filters: [{&:logger_filters.remote_gl/2, :stop}],
  filter_default: :log,
  formatter: &Logger.default_formatter/0,
  level: :all,
  module: :logger_std_h
]

The :config customizes a specific handler module. The default handler is :logger_std_h, which logs to standard IO, and you call find all relevant configuration in its module documentation, including information overload protection.

You may also set :default_handler to false to disable the default logging altogether:

config :logger, :default_handler, false

How to add more handlers besides the default one is covered in later sections.

Compile configuration

The following configuration must be set via config files (such as config/config.exs) under the :logger application before your code is compiled:

• :always_evaluate_messages - if messages should be evaluated even if the log level is lower than the minimum configured level. Defaults to false. This is useful for cases where the log level in your test environment is high (such as :error), which is common in order to avoid logs mixed with the test output. In such, cases, you might discover log messages that contain runtime errors only when your code is deployed to production, where the log level is lower (such as :info). These runtime errors could be caused by, for example, interpolating something that doesn't implement the String.Chars protocol in the log message, such as "PID: #{self()}" (since PIDs cannot be converted to strings with String.Chars).

• :compile_time_application - sets the :application metadata value to the configured value at compilation time. This configuration is automatically set by Mix and made available as metadata when logging.

• :compile_time_purge_matching - purges at compilation time all calls that match the given conditions. This means that Logger calls with level lower than this option will be completely removed at compile time, accruing no overhead at runtime. This configuration expects a list of keyword lists. Each keyword list contains a metadata key and the matching value that should be purged. Some special keys are supported:

  • :level_lower_than - purges all messages with a lower logger level
  • :module - purges all messages with the matching module
  • :function - purges all messages with the "function/arity"

  Remember that if you want to purge log calls from a dependency, the dependency must be recompiled.

For example, to purge all calls that happen at compile time with level lower than :info in a config/config.exs file:

config :logger,
  compile_time_purge_matching: [
    [level_lower_than: :info]
  ]

If you want to purge all log calls from an application named :foo and only keep errors from Bar.foo/3, you can set up two different matches:

config :logger,
  compile_time_purge_matching: [
    [application: :foo],
    [module: Bar, function: "foo/3", level_lower_than: :error]
  ]

Runtime Configuration

All configuration below can be set via config files (such as config/config.exs) but also changed dynamically during runtime via Logger.configure/1.

• :level - the logging level. Attempting to log any message with severity less than the configured level will simply cause the message to be ignored. Keep in mind that each handler may have its specific level, too. In addition to levels mentioned above it also supports 2 "meta-levels":

  • :all - all messages will be logged, conceptually identical to :debug
  • :none - no messages will be logged at all

• :translator_inspect_opts - when translating OTP reports and errors, the last message and state must be inspected in the error reports. This configuration allow developers to change how much and how the data should be inspected.

For example, to configure the :level options in a config/config.exs file:

config :logger, level: :warning

Furthermore, Logger allows messages sent by Erlang to be translated into an Elixir format via translators. Translators can be added at any time with the add_translator/1 and remove_translator/1 APIs. Check Logger.Translator for more information.

Erlang/OTP handlers

Handlers represent the ability to integrate into the logging system to handle each logged message/event. Elixir's Logger automatically sets a default handler based on Erlang's :logger_std_h, which you can configure using the :default_handler boot configuration outlined above. You may also attach additional handlers when you boot your application.

To do so, you must list a series of handlers under the :logger key of your application configuration. For example, to setup an additional handler that writes to a file:

config :my_app, :logger, [
  {:handler, :file_log, :logger_std_h, %{
     config: %{
       file: ~c"system.log",
       filesync_repeat_interval: 5000,
       file_check: 5000,
       max_no_bytes: 10_000_000,
       max_no_files: 5,
       compress_on_rotate: true
     },
     formatter: Logger.Formatter.new()
   }}
]

Each handler has the shape {:handler, name, handler_module, config_map}. Once defined, a handler can be explicitly attached in your Application.start/2 callback with add_handlers/1:

Logger.add_handlers(:my_app)

You can also add, remove, and update handlers at runtime with the help of the Erlang's :logger module.

You may also develop your own handlers. Handlers run in the same process as the process logging the message/event. This gives developers flexibility but they should avoid performing any long running action in such handlers, as it may slow down the action being executed considerably. At the moment, there is no built-in overload protection for Erlang handlers, so it is your responsibility to implement it.

Alternatively, you can use the :logger_backends project. It sets up a log handler with overload protection and allows incoming events to be dispatched to multiple backends.

Filtering

You can add filters to any handler. For example, to filter out logs that contain a particular string, you could create a module:

defmodule LogFilter do
  def filter(log_event, _opts) do
    case log_event do
      %{msg: msg} when is_binary(msg) ->
        if msg =~ "password" do
          :stop
        else
          :ignore
        end

      _ ->
        :ignore
    end
  end
end

It may return :log (to log the message), :stop (to not log the message), or :ignore (to ignore the filter).

Then you can attach the filter, either as a primary filter (which applies to all handlers), or to a specific handler, when you start your application, such as in the Application.start/2 callback:

:logger.add_primary_filter(:word_filter, {&LogFilter.filter/2, []})

Backends and backwards compatibility

Prior to Elixir v1.15, custom logging could be achieved with Logger backends. The main API for writing Logger backends have been moved to the :logger_backends project. However, the backends API is still part of Elixir for backwards compatibility.

Important remarks:

• If the :backends key is set and it doesn't have the :console entry, we assume that you want to disable the built-in logging. You can force logging by setting config :logger, :default_handler, []

• The :console backend configuration is automatically mapped to the default handler and default formatter. Previously, you would set:

  config :logger, :console,
    level: :error,
    format: "$time $message $metadata"

  This is now equivalent to:

  config :logger, :default_handler,
    level: :error
  
  config :logger, :default_formatter,
    format: "$time $message $metadata"

  All previous console configuration, except for :level, now go under :default_formatter.

• If you want to use the previous :console implementation based on Logger Backends, you can still set backends: [Logger.Backends.Console] and place the configuration under config :logger, Logger.Backends.Console. Although consider using the :logger_backends project in such cases, as Logger.Backends.Console itself will be deprecated in future releases

• Logger.Backends only receive :debug, :info, :warning, and :error messages. :notice maps to :info. :warn maps to :warnings. All others map to :error