Logger

https://hexdocs.pm/logger/Logger.html
Admin
Logger is a logging library for Elixir applications that provides multiple log levels, structured...
Tokens:7,925
Snippets:97
Trust Score:9.7
Update:6 months ago
Show doc for...
Tokens:
Raw
### Attach handlers in application start

Source: https://hexdocs.pm/logger/Logger.html

Call this function in your Application.start/2 callback to register configured handlers.

```elixir
Logger.add_handlers(:my_app)
```

--------------------------------

### Get available levels

Source: https://hexdocs.pm/logger/Logger.html

Returns a list of all available logging levels.

```elixir
@spec levels() :: [level(), ...]
```

--------------------------------

### Get process logging level

Source: https://hexdocs.pm/logger/Logger.html

Retrieves the effective logging level for the current process.

```elixir
@spec get_process_level(pid()) :: level() | :all | :none | nil
```

--------------------------------

### Get Default Formatter Configuration

Source: https://hexdocs.pm/logger/Logger.html

Retrieves the default formatter configuration used by Logger. Allows overriding default settings by providing a list of options.

```elixir
@spec default_formatter(formatter_opts()) :: {module(), :logger.formatter_config()}
```

```elixir
config :logger, :default_formatter,
  format: "\n$time $metadata[$level] $message\n",
  metadata: [:user_id]
```

```elixir
setup tags do
  formatter = Logger.default_formatter(colors: [enabled: false])
  :logger.update_handler_config(:default, :formatter, formatter)

  on_exit(fn ->
    :logger.update_handler_config(:default, :formatter, Logger.default_formatter())
  end)
end
```

--------------------------------

### Get module logging level

Source: https://hexdocs.pm/logger/Logger.html

Retrieves the effective logging level for a given module or list of modules.

```elixir
@spec get_module_level(module() | [module()]) :: [{module(), level() | :all | :none}]
```

--------------------------------

### Migrate console configuration

Source: https://hexdocs.pm/logger/Logger.html

Compare legacy console backend configuration with the modern default handler and formatter configuration.

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

```elixir
config :logger, :default_handler,
  level: :error

config :logger, :default_formatter,
  format: "$time $message $metadata"
```

--------------------------------

### Log a Notice Message with Metadata (Keyword List)

Source: https://hexdocs.pm/logger/Logger.html

Logs a notice message along with contextual metadata provided as a keyword list. This helps in filtering and analyzing logs.

```elixir
Logger.notice("this is a notice message", [user_id: 42, request_id: "xU32kFa"])
```

--------------------------------

### Log a Notice Message with Keyword List

Source: https://hexdocs.pm/logger/Logger.html

Logs a notice message with associated metadata provided as a keyword list. This is useful for structured logging.

```elixir
Logger.notice([something: :reported, this: :notice])
```

--------------------------------

### Configure OTP and SASL report handling

Source: https://hexdocs.pm/logger/Logger.html

Enables logging for Erlang/OTP and SASL reports in config/config.exs.

```elixir
config :logger,
  handle_otp_reports: true,
  handle_sasl_reports: true
```

--------------------------------

### Configure default handler for file logging

Source: https://hexdocs.pm/logger/Logger.html

Configures the default handler to log to a file with rotation and compression settings.

```elixir
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
  ]
```

--------------------------------

### Configure default formatter

Source: https://hexdocs.pm/logger/Logger.html

Sets a custom format string and metadata keys for the default logger formatter.

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

--------------------------------

### Attach a primary log filter

Source: https://hexdocs.pm/logger/Logger.html

Register a filter globally to apply it to all handlers during application startup.

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

--------------------------------

### Define configure_opts type

Source: https://hexdocs.pm/logger/Logger.html

Defines the configuration options for the Logger.

```elixir
@type configure_opts() :: [
  level: level(),
  translator_inspect_opts: Inspect.Opts.t(),
  sync_threshold: non_neg_integer(),
  discard_threshold: non_neg_integer(),
  truncate: non_neg_integer() | :infinity,
  utc_log: boolean()
]
```

--------------------------------

### Log a Notice Message with Metadata (Map)

Source: https://hexdocs.pm/logger/Logger.html

Logs a notice message with contextual metadata provided as a map. This is an alternative to keyword lists for structured logging.

```elixir
Logger.notice("this is a notice message", %{user_id: 42, request_id: "xU32kFa"})
```

--------------------------------

### Log a Notice Message

Source: https://hexdocs.pm/logger/Logger.html

Logs a simple notice message. Use this for general informational messages.

```elixir
Logger.notice("this is a notice message")
```

--------------------------------

### Default handler configuration reference

Source: https://hexdocs.pm/logger/Logger.html

Displays the default configuration structure for the logger_std_h handler.

```elixir
[
  # 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
]
```

--------------------------------

### Log a Warning Message with Metadata (Keyword List)

Source: https://hexdocs.pm/logger/Logger.html

Logs a warning message along with contextual metadata provided as a keyword list. This aids in diagnosing the cause of warnings.

```elixir
Logger.warning("this is a warning message", [user_id: 42, request_id: "xU32kFa"])
```

--------------------------------

### Level Comparison and Configuration

Source: https://hexdocs.pm/logger/Logger.html

Functions for comparing log levels and configuring the logger's behavior.

```APIDOC
## compare_levels(left, right)

### Description
Compares two log levels. Returns `:lt` if `left` is less than `right`, `:eq` if they are equal, and `:gt` if `left` is greater than `right`.

### Method
`Logger.compare_levels/2`

### Parameters
- **left** (level()) - The left log level.
- **right** (level()) - The right log level.

### Response
- `:lt` | `:eq` | `:gt` - The comparison result.

### Examples
```elixir
iex> Logger.compare_levels(:debug, :warning)
:lt
iex> Logger.compare_levels(:error, :info)
:gt
```

## configure(options)

### Description
Configures the logger with the given options. Changes are persisted to the `:logger` application environment.

### Method
`Logger.configure/1`

### Parameters
- **options** (configure_opts()) - A keyword list of configuration options.

### Response
- `:ok`

## configure_backend(backend, options)

### Description
Configures the given backend. This function is deprecated. Use `LoggerBackends.configure/2` instead.

### Method
`Logger.configure_backend/2`

### Parameters
- **backend** - The backend to configure.
- **options** - The configuration options for the backend.

## default_formatter(overrides \\ [])

### Description
Returns the default formatter used by Logger, potentially with overrides. This is useful for programmatically setting up handlers, especially in tests.

### Method
`Logger.default_formatter/1`

### Parameters
- **overrides** (formatter_opts()) - A list of overrides for the default formatter configuration.

### Response
- `{module(), :logger.formatter_config()}` - A tuple containing the formatter module and its configuration.

### Examples
```elixir
setup tags do
  formatter = Logger.default_formatter(colors: [enabled: false])
  :logger.update_handler_config(:default, :formatter, formatter)

  on_exit(fn ->
    :logger.update_handler_config(:default, :formatter, Logger.default_formatter())
  end)
end
```

## delete_all_module_levels()

### Description
Resets the logging level for all modules to the primary level.

### Method
`Logger.delete_all_module_levels/0`

### Response
- `:ok`

## delete_application_level(appname)

### Description
Resets the logging level for all modules within a given application to the primary level.

### Method
`Logger.delete_application_level/1`

### Parameters
- **appname** (application) - The name of the application.

### Response
- `:ok` | `{:error, {:not_loaded, application}}`

## delete_module_level(module)

### Description
Resets the logging level for a given module or a list of modules to the primary level.

### Method
`Logger.delete_module_level/1`

### Parameters
- **module** (module() | [module()]) - The module or list of modules to reset.

### Response
- `:ok`

## delete_process_level(pid)

### Description
Resets the logging level for the current process to the primary level. Currently, only `self()` is accepted as a PID.

### Method
`Logger.delete_process_level/1`

### Parameters
- **pid** (pid()) - The process identifier (currently only `self()` is supported).

### Response
- `:ok`
```

--------------------------------

### Log a Warning Message with Keyword List

Source: https://hexdocs.pm/logger/Logger.html

Logs a warning message with associated metadata provided as a keyword list. This is useful for structured logging of warnings.

```elixir
Logger.warning([something: :reported, this: :warning])
```

--------------------------------

### Log a Notice Message with Map

Source: https://hexdocs.pm/logger/Logger.html

Logs a notice message with associated metadata provided as a map. This is an alternative to keyword lists for structured logging.

```elixir
Logger.notice(%{this: :notice, something: :reported})
```

--------------------------------

### Logger Configuration and Utility

Source: https://hexdocs.pm/logger/Logger.html

Utility functions for flushing logs, retrieving levels, and reading process metadata.

```APIDOC
## flush()

### Description
Flushes the logger to ensure all handlers write to storage. Should be used sparingly in production.

### Response
- **result** (:ok) - Returns :ok.
```

--------------------------------

### Log Structured Message with Keyword List

Source: https://hexdocs.pm/logger/Logger.html

Logger.info/1 can log structured data using a keyword list. Arguments are only evaluated if the log level permits.

```elixir
Logger.info([new_user: user.id, account_type: :admin])
```

--------------------------------

### Configure Application Level Logging

Source: https://hexdocs.pm/logger/Logger.html

Sets the logging level for all modules within a specific application. This configuration takes precedence over the global level.

```elixir
@spec put_application_level(atom(), level() | :all | :none) ::
  :ok | {:error, :not_loaded}
```

--------------------------------

### Configure Process Level Logging

Source: https://hexdocs.pm/logger/Logger.html

Sets the logging level for the current process. This level works in conjunction with the global level, using the higher of the two.

```elixir
@spec put_process_level(pid(), level() | :all | :none) :: :ok
```

--------------------------------

### Log a Warning Message with Metadata (Map)

Source: https://hexdocs.pm/logger/Logger.html

Logs a warning message with contextual metadata provided as a map. This is an alternative to keyword lists for structured warning logs.

```elixir
Logger.warning("this is a warning message", %{user_id: 42, request_id: "xU32kFa"})
```

--------------------------------

### Enable logging for a process

Source: https://hexdocs.pm/logger/Logger.html

Deprecated function to enable logging for the current process. Use Logger.delete_process_level(pid) instead.

```elixir
@spec enable(pid()) :: :ok
```

```elixir
delete_process_level(pid)
```

--------------------------------

### Configure runtime log level

Source: https://hexdocs.pm/logger/Logger.html

Set the global logging level in config/config.exs to filter messages by severity.

```elixir
config :logger, level: :warning
```

--------------------------------

### Define level type

Source: https://hexdocs.pm/logger/Logger.html

Defines the available log levels.

```elixir
@type level() ::
  :emergency
  | :alert
  | :critical
  | :error
  | :warning
  | :warn
  | :notice
  | :info
  | :debug
```

--------------------------------

### add_handlers/1

Source: https://hexdocs.pm/logger/Logger.html

Registers new handlers into the logging system based on the application configuration.

```APIDOC
## add_handlers(app)

### Description
Adds the handlers configured in the :logger application parameter of the given app.

### Parameters
#### Arguments
- **app** (atom) - Required - The application name to load handlers from.

### Response
- **:ok** - Success
- **{:error, term()}** - Failure
```

--------------------------------

### Log Structured Message with Map

Source: https://hexdocs.pm/logger/Logger.html

Logger.info/1 can log structured data using a map. Arguments are only evaluated if the log level permits.

```elixir
Logger.info(%{new_user: user.id, account_type: :admin})
```

--------------------------------

### alert/2

Source: https://hexdocs.pm/logger/Logger.html

Logs an alert message with optional metadata.

```APIDOC
## alert(message_or_fun, metadata)

### Description
Logs an alert message. Returns :ok.

### Parameters
#### Arguments
- **message_or_fun** (String.t | map | keyword) - Required - The message to log.
- **metadata** (keyword | map) - Optional - Metadata to associate with the log entry.

### Response
- **:ok** - Success
```

--------------------------------

### Configure a custom Logger handler

Source: https://hexdocs.pm/logger/Logger.html

Register the custom handler in the application configuration file.

```elixir
config :my_app, :logger, [
  {:handler, :my_handler, MyApp.CustomHandler, _config = %{}}
]
```

--------------------------------

### Log a Warning Message

Source: https://hexdocs.pm/logger/Logger.html

Logs a warning message. Use this for potential issues that do not necessarily stop execution.

```elixir
Logger.warning("this is a warning message")
```

--------------------------------

### Define formatter_opts type

Source: https://hexdocs.pm/logger/Logger.html

Defines the formatting options for log messages.

```elixir
@type formatter_opts() :: [
  colors: [
    enabled: boolean(),
    debug: atom(),
    info: atom(),
    warning: atom(),
    error: atom()
  ],
  format: String.t() | {module(), atom()},
  metadata: :all | [atom()],
  truncate: pos_integer() | :infinity,
  utc_log: boolean()
]
```

--------------------------------

### Log Message with Zero-Arity Anonymous Function

Source: https://hexdocs.pm/logger/Logger.html

Logger.info/1 can accept a zero-arity anonymous function that returns the message. Arguments are only evaluated if the log level permits.

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

--------------------------------

### Log a Warning Message with Map

Source: https://hexdocs.pm/logger/Logger.html

Logs a warning message with associated metadata provided as a map. This is an alternative to keyword lists for structured warning logs.

```elixir
Logger.warning(%{this: :warning, something: :reported})
```

--------------------------------

### Logger Configuration

Source: https://hexdocs.pm/logger/Logger.html

Functions to configure logging levels for applications, modules, and processes.

```APIDOC
## put_application_level(appname, level)

### Description
Puts logging level for modules in a given application.

### Parameters
- **appname** (atom) - Required - The application name.
- **level** (level | :all | :none) - Required - The logging level.

## put_module_level(mod, level)

### Description
Puts logging level for a specific module or list of modules.

### Parameters
- **mod** (module | [module]) - Required - The module(s) to configure.
- **level** (level | :all | :none) - Required - The logging level.

## put_process_level(pid, level)

### Description
Puts logging level for the current process (self()).

### Parameters
- **pid** (pid) - Required - The process ID (must be self()).
- **level** (level | :all | :none) - Required - The logging level.
```

--------------------------------

### Process Level Management

Source: https://hexdocs.pm/logger/Logger.html

Functions to manage logging levels for specific processes.

```APIDOC
## get_process_level(pid)

### Description
Gets the logging level for the current process.

### Parameters
- **pid** (pid()) - Required - The process identifier (currently only self() is accepted).

### Response
- **level** (level() | :all | :none | nil) - The effective logging level or nil if not set.
```

--------------------------------

### Read process metadata

Source: https://hexdocs.pm/logger/Logger.html

Reads the metadata associated with the current process.

```elixir
@spec metadata() :: metadata()
```

--------------------------------

### Configure Module Level Logging

Source: https://hexdocs.pm/logger/Logger.html

Sets the logging level for a specific module or a list of modules. This level overrides the global configuration, allowing for fine-grained control.

```elixir
Logger.configure(level: :error)
Logger.put_module_level(Foo, :all)

Foo.log()
# This will print the message even if global level is :error
```

--------------------------------

### Log info messages

Source: https://hexdocs.pm/logger/Logger.html

Logs an info message with optional metadata.

```elixir
Logger.info("this is an info message")
```

```elixir
# as keyword list
Logger.info([something: :reported, this: :info])

# as map
Logger.info(%{this: :info, something: :reported})
```

```elixir
# as a keyword list
Logger.info("this is an info message", [user_id: 42, request_id: "xU32kFa"])

# as map
Logger.info("this is an info message", %{user_id: 42, request_id: "xU32kFa"})
```

--------------------------------

### Create a log filter module

Source: https://hexdocs.pm/logger/Logger.html

Define a filter module to selectively ignore or stop log events based on their content. The filter function must return :log, :stop, or :ignore.

```elixir
defmodule LogFilter do
  def filter(log_event, _opts) do
    case log_event do
      %{msg: {:string, msg}} ->
        # msg may be a charlist or a binary
        if to_string(msg) =~ "password" do
          :stop
        else
          :ignore
        end

      _ ->
        :ignore
    end
  end
end
```

--------------------------------

### Logging Functions

Source: https://hexdocs.pm/logger/Logger.html

Functions for logging messages at different levels. Some functions evaluate arguments dynamically, while others only evaluate them if the log level is appropriate.

```APIDOC
## bare_log(level, message_or_fun, metadata \\ [])

### Description
Logs a message dynamically. All arguments are always evaluated. Anonymous functions are only evaluated if there is something to be logged.

### Method
`Logger.bare_log/3`

### Parameters
- **level** (level()) - The log level.
- **message_or_fun** (message() | (-> message() | {message(), keyword()})) - The message to log or a function that returns the message.
- **metadata** (metadata()) - Optional metadata to include with the log.

### Response
- `:ok`

## critical(message_or_fun, metadata \\ [])

### Description
Logs a critical message. This is a macro that evaluates its arguments only if the log level is appropriate.

### Method
`Logger.critical/2`

### Parameters
- **message_or_fun** (message() | (-> message() | {message(), keyword()})) - The message to log or a function that returns the message.
- **metadata** (metadata()) - Optional metadata to include with the log.

### Request Example
```elixir
Logger.critical("this is a critical message")
Logger.critical([something: :reported, this: :critical])
Logger.critical("this is a critical message", [user_id: 42, request_id: "xU32kFa"])
```

### Response
- `:ok`

## debug(message_or_fun, metadata \\ [])

### Description
Logs a debug message. This is a macro that evaluates its arguments only if the log level is appropriate.

### Method
`Logger.debug/2`

### Parameters
- **message_or_fun** (message() | (-> message() | {message(), keyword()})) - The message to log or a function that returns the message.
- **metadata** (metadata()) - Optional metadata to include with the log.

### Request Example
```elixir
Logger.debug("this is a debug message")
Logger.debug([something: :reported, this: :debug])
Logger.debug("this is a debug message", [user_id: 42, request_id: "xU32kFa"])
```

### Response
- `:ok`
```

--------------------------------

### Logger Logging Macros

Source: https://hexdocs.pm/logger/Logger.html

Macros for logging messages at specific severity levels including emergency, error, and info.

```APIDOC
## Logger Logging Macros

### Description
Logs a message at a specific severity level. Macros are preferred over the generic log/3 function for compile-time optimization.

### Parameters
- **message_or_fun** (string | iodata | map | keyword) - Required - The message to log.
- **metadata** (keyword | map) - Optional - Additional metadata to associate with the log entry.

### Request Example
Logger.info("this is an info message", [user_id: 42])

### Response
- **result** (:ok) - Returns :ok upon successful logging.
```

--------------------------------

### Configure compile-time purge matching

Source: https://hexdocs.pm/logger/Logger.html

Use this configuration in config/config.exs to remove log calls at compile time based on level or metadata.

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

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

--------------------------------

### Log Dynamically

Source: https://hexdocs.pm/logger/Logger.html

Logs a message dynamically. Arguments are always evaluated, but anonymous functions are only evaluated if logging is enabled.

```elixir
@spec bare_log(
  level(),
  message() | (-> message() | {message(), keyword()}),
  metadata()
) :: :ok
```

--------------------------------

### Log Unstructured String Message

Source: https://hexdocs.pm/logger/Logger.html

Logger.info/1 can log a simple string message. Arguments are only evaluated if the log level permits.

```elixir
Logger.info("hello world!")
```

--------------------------------

### Compare Log Levels

Source: https://hexdocs.pm/logger/Logger.html

Compares two log levels to determine their order. Returns :lt if left is less than right, :eq if equal, and :gt if left is greater than right.

```elixir
@spec compare_levels(level(), level()) :: :lt | :eq | :gt
```

```elixir
iex> Logger.compare_levels(:debug, :warning)
:lt
```

```elixir
iex> Logger.compare_levels(:error, :info)
:gt
```

--------------------------------

### Add handlers

Source: https://hexdocs.pm/logger/Logger.html

Adds handlers configured in the logger application parameter for a given app.

```elixir
@spec add_handlers(atom()) :: :ok | {:error, term()}
```

--------------------------------

### Define additional logger handler

Source: https://hexdocs.pm/logger/Logger.html

Add a custom handler in your application configuration to write logs to a file.

```elixir
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()
   }}
]
```

--------------------------------

### Add translator

Source: https://hexdocs.pm/logger/Logger.html

Adds a new translator to the logger.

```elixir
@spec add_translator({module(), function :: atom()}) :: :ok
```

--------------------------------

### add_translator/1

Source: https://hexdocs.pm/logger/Logger.html

Adds a new translator to the logging system.

```APIDOC
## add_translator(translator)

### Description
Adds a new translator to the system.

### Parameters
#### Arguments
- **translator** ({module(), function :: atom()}) - Required - The translator module and function.

### Response
- **:ok** - Success
```

--------------------------------

### Log User Deletion Event

Source: https://hexdocs.pm/logger/Logger.html

Use Logger.info/2 to emit an informational message about an event. Arguments are only evaluated if the log level permits.

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

--------------------------------

### Implement a custom Logger handler

Source: https://hexdocs.pm/logger/Logger.html

Define a module implementing the :logger_handler behaviour to process log events. Avoid long-running operations within the log callback to prevent performance degradation.

```elixir
defmodule MyApp.CustomHandler do
  @behaviour :logger_handler

  def log(event, _config) do
    IO.inspect(event)
  end
end
```

--------------------------------

### Log Unstructured List Message

Source: https://hexdocs.pm/logger/Logger.html

Logger.info/1 can log a list of strings as an unstructured message. Arguments are only evaluated if the log level permits.

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

--------------------------------

### Define message type

Source: https://hexdocs.pm/logger/Logger.html

Defines the allowed types for log messages.

```elixir
@type message() :: :unicode.chardata() | String.Chars.t() | report()
```

--------------------------------

### Logger Message Reporting

Source: https://hexdocs.pm/logger/Logger.html

Macros for logging messages at specific severity levels.

```APIDOC
## notice(message_or_fun, metadata)

### Description
Logs a notice message.

### Parameters
- **message_or_fun** (string | iodata | map | keyword) - Required - The message to log.
- **metadata** (map | keyword) - Optional - Metadata to associate with the log.

### Response
- **:ok** (atom) - Success status.

## warning(message_or_fun, metadata)

### Description
Logs a warning message.

### Parameters
- **message_or_fun** (string | iodata | map | keyword) - Required - The message to log.
- **metadata** (map | keyword) - Optional - Metadata to associate with the log.

### Response
- **:ok** (atom) - Success status.
```

--------------------------------

### Define report type

Source: https://hexdocs.pm/logger/Logger.html

Defines the report type as a map or keyword list.

```elixir
@type report() :: map() | keyword()
```

--------------------------------

### Logger Metadata Management

Source: https://hexdocs.pm/logger/Logger.html

Functions for managing process-specific metadata used in log entries.

```APIDOC
## metadata(enumerable)

### Description
Alters the current process metadata by merging the given enumerable. Setting a key to nil removes it.

### Parameters
- **enumerable** (Enumerable.t({atom(), term()})) - Required - The metadata to merge.

### Response
- **:ok** (atom) - Success status.

## reset_metadata(enumerable)

### Description
Resets the current process metadata to the provided enumerable.

### Parameters
- **enumerable** (Enumerable.t({atom(), term()})) - Optional - The new metadata to set.
```

--------------------------------

### Flush the logger

Source: https://hexdocs.pm/logger/Logger.html

Forces all logger handlers to flush to disk or storage. Avoid in production as it may impact performance.

```elixir
@spec flush() :: :ok
```

--------------------------------

### Define metadata type

Source: https://hexdocs.pm/logger/Logger.html

Defines the metadata type as a keyword list.

```elixir
@type metadata() :: keyword()
```

--------------------------------

### Log alert message

Source: https://hexdocs.pm/logger/Logger.html

Logs an alert message with optional metadata.

```elixir
Logger.alert("this is an alert message")
```

```elixir
# as keyword list
Logger.alert([something: :reported, this: :alert])

# as map
Logger.alert(%{this: :alert, something: :reported})
```

```elixir
# as a keyword list
Logger.alert("this is an alert message", [user_id: 42, request_id: "xU32kFa"])

# as map
Logger.alert("this is an alert message", %{user_id: 42, request_id: "xU32kFa"})
```

--------------------------------

### Retrieve logger level

Source: https://hexdocs.pm/logger/Logger.html

Retrieves the current global Logger level.

```elixir
@spec level() :: level() | :all | :none
```

--------------------------------

### Check if logging is enabled

Source: https://hexdocs.pm/logger/Logger.html

Deprecated function to check if logging is enabled for a process. Use Logger.get_process_level(pid) instead.

```elixir
@spec enabled?(pid()) :: boolean()
```

--------------------------------

### Log error messages

Source: https://hexdocs.pm/logger/Logger.html

Logs an error message with optional metadata.

```elixir
Logger.error("this is an error message")
```

```elixir
# as keyword list
Logger.error([something: :reported, this: :error])

# as map
Logger.error(%{this: :error, something: :reported})
```

```elixir
# as a keyword list
Logger.error("this is an error message", [user_id: 42, request_id: "xU32kFa"])

# as map
Logger.error("this is an error message", %{user_id: 42, request_id: "xU32kFa"})
```

--------------------------------

### Logger Reset Metadata Specification

Source: https://hexdocs.pm/logger/Logger.html

Defines the type specification for the reset_metadata function, which accepts an enumerable of atom-term pairs.

```elixir
@spec reset_metadata(Enumerable.t({atom(), term()})) :: :ok
```

--------------------------------

### Log emergency messages

Source: https://hexdocs.pm/logger/Logger.html

Logs an emergency message with optional metadata. Supports strings, iodata, maps, or keyword lists.

```elixir
Logger.emergency("this is an emergency message")
```

```elixir
# as keyword list
Logger.emergency([something: :reported, this: :emergency])

# as map
Logger.emergency(%{this: :emergency, something: :reported})
```

```elixir
# as a keyword list
Logger.emergency("this is an emergency message", [user_id: 42, request_id: "xU32kFa"])

# as map
Logger.emergency("this is an emergency message", %{user_id: 42, request_id: "xU32kFa"})
```

--------------------------------

### Logger Metadata Type Specification

Source: https://hexdocs.pm/logger/Logger.html

Defines the type specification for the metadata function, indicating it accepts an enumerable of atom-term pairs.

```elixir
@spec metadata(Enumerable.t({atom(), term()})) :: :ok
```

--------------------------------

### Delete Process Logging Level

Source: https://hexdocs.pm/logger/Logger.html

Resets the logging level for the current process to the primary level. Currently, only `self()` is accepted as a PID.

```elixir
@spec delete_process_level(pid()) :: :ok
```

```elixir
self()
```

--------------------------------

### Disable logging for a process

Source: https://hexdocs.pm/logger/Logger.html

Deprecated function to disable logging for the current process. Use Logger.put_process_level(pid, :none) instead.

```elixir
@spec disable(pid()) :: :ok
```

```elixir
put_process_level(pid, :none)
```

--------------------------------

### Disable default handler

Source: https://hexdocs.pm/logger/Logger.html

Disables the default logging handler entirely.

```elixir
config :logger, :default_handler, false
```

--------------------------------

### Log Critical Message

Source: https://hexdocs.pm/logger/Logger.html

Logs a critical message. Can accept a string or iodata for the message, and optionally metadata as a keyword list or map.

```elixir
Logger.critical("this is a critical message")
```

```elixir
# as keyword list
Logger.critical([something: :reported, this: :critical])
```

```elixir
# as map
Logger.critical(%{this: :critical, something: :reported})
```

```elixir
# as a keyword list
Logger.critical("this is a critical message", [user_id: 42, request_id: "xU32kFa"])
```

```elixir
# as map
Logger.critical("this is a critical message", %{user_id: 42, request_id: "xU32kFa"})
```

--------------------------------

### Add Custom Metadata to Log Message

Source: https://hexdocs.pm/logger/Logger.html

Pass custom metadata, such as an :error_code, directly within a Logger invocation. This is useful for including specific context for a particular log entry.

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

--------------------------------

### Delete All Module Logging Levels

Source: https://hexdocs.pm/logger/Logger.html

Resets the logging level for all modules to the primary level. This function is useful for resetting all custom module log level configurations.

```elixir
@spec delete_all_module_levels() :: :ok
```

--------------------------------

### Log Debug Message

Source: https://hexdocs.pm/logger/Logger.html

Logs a debug message. Supports message as string or iodata, and optional metadata as keyword list or map.

```elixir
Logger.debug("this is a debug message")
```

```elixir
# as keyword list
Logger.debug([something: :reported, this: :debug])
```

```elixir
# as map
Logger.debug(%{this: :debug, something: :reported})
```

```elixir
# as a keyword list
Logger.debug("this is a debug message", [user_id: 42, request_id: "xU32kFa"])
```

```elixir
# as map
Logger.debug("this is a debug message", %{user_id: 42, request_id: "xU32kFa"})
```

--------------------------------

### Delete Module Logging Level

Source: https://hexdocs.pm/logger/Logger.html

Resets the logging level for a specified module or a list of modules to the primary level. This allows fine-grained control over which modules' log levels are reset.

```elixir
@spec delete_module_level(module() | [module()]) :: :ok
```

--------------------------------

### Delete Application Logging Level

Source: https://hexdocs.pm/logger/Logger.html

Resets the logging level for all modules within a specified application to the primary level. This is equivalent to deleting the module level for each module in the application.

```elixir
@spec delete_application_level(application) ::
  :ok | {:error, {:not_loaded, application}}
when application: atom()
```

```elixir
appname |> Application.spec(:modules) |> Logger.delete_module_level()
```

--------------------------------

### Logger Remove Translator Specification

Source: https://hexdocs.pm/logger/Logger.html

Defines the type specification for the remove_translator function, which accepts a module and function atom.

```elixir
@spec remove_translator({module(), function :: atom()}) :: :ok
```
Tokens:
Raw