LoggerJSON

LoggerJSON provides several specialized formatters for different platforms:

• LoggerJSON.Formatters.Basic: A generic structured JSON format suitable for any system.
• LoggerJSON.Formatters.GoogleCloud: Formats logs for Google Cloud Logger and Google Cloud Error Reporter.
• LoggerJSON.Formatters.Datadog: Formats logs following Datadog's standard attribute naming conventions.
• LoggerJSON.Formatters.Elastic: Formats logs conforming to the Elastic Common Schema (ECS) for use with ElasticSearch, LogStash, etc.

The LoggerJSON.Formatters.Elastic formatter ensures logs conform to ECS.

• Errors: When an exception is thrown, the message field is populated with the error message, and error.message, error.stack_trace, and error.type fields are automatically set.
• Custom Exceptions: If you define a custom exception type with id and/or code fields, these will be mapped to error.id and error.code respectively.
• Custom Metadata: Any custom metadata added via Logger.metadata/1 or passed directly to the log call is added to the root of the JSON object, allowing you to populate additional ECS fields.

Add logger_json to your mix.exs dependencies and run mix deps.get to install.

def deps do
  [
    # ...
    {:logger_json, "~> 7.0"}
    # ...
  ]
end

To make your logging level configurable via the LOG_LEVEL environment variable, call LoggerJSON.configure_log_level_from_env!() within your application's startup logic (e.g., in application.ex).

# Inside application.ex
LoggerJSON.configure_log_level_from_env!()

LoggerJSON provides several formatters tailored for different logging ecosystems:

• LoggerJSON.Formatters.Basic: A standard JSON formatter for any structured logging system (e.g., ElasticSearch, Logstash).
• LoggerJSON.Formatters.GoogleCloud: Formatter for Google Cloud Logger and Google Cloud Error Reporter.
• LoggerJSON.Formatters.Datadog: Formatter for Datadog.
• LoggerJSON.Formatters.Elastic: Formatter conforming to the Elastic Common Schema (ECS) for ElasticSearch, LogStash, FileBeat, and Kibana.

If you need to decide whether to log a request based on its content (e.g., logging only errors or specific paths), you can provide a dynamic level handler.

Pass a tuple {Module, function, arguments} as the third argument to LoggerJSON.Plug.attach/3. The handler will call Module.function(conn, arguments_list) where conn is automatically prepended to the arguments.

Return a valid Logger.level() (like :info, :warn, :error) to log, or false to skip logging.

defmodule MyLoggerLevel do
  def should_log(conn, "/health_check")
    false # Do not log health checks
  end

  def should_log(_conn, _)
    :info # Log everything else at :info level
  end
end

# Attaching with the dynamic handler
LoggerJSON.Plug.attach("dynamic-logger", [:myapp, :plug, :stop], {MyLoggerLevel, :should_log, []})

The Basic formatter can automatically compute "virtual" metadata keys from the :mfa (Module, Function, Arity) entry in your log metadata. This mirrors the behavior of Elixir's built-in Logger.Formatter.

Supported virtual keys:

• :module: Extracted from the module in the :mfa tuple.
• :function: Extracted as a string in the format "function_name/arity".
• :initial_call: Extracted using Exception.format_mfa/3.

These keys are automatically included if they are not already present in the metadata and if the :metadata configuration allows for them.

By default, LoggerJSON uses Jason as the JSON encoder. If you are using Elixir 1.18 or later, you can switch to the built-in JSON module by setting the :encoder option in your config.exs. This must be done at compile-time.

config :logger_json, encoder: JSON

If Plug.Conn is loaded in your application, the Basic formatter automatically detects if a :conn key (containing a %Plug.Conn{} struct) is present in the log metadata. If found, it extracts and adds a request key to the JSON output containing:

• connection: protocol, method, path, and status.
• client: user_agent and ip.