Allow using old tuples in config.exs and promote using new/1 in runtime.exs

Author: AndrewDryga

README.md

@@ -35,20 +35,28 @@ end
 
 and install it running `mix deps.get`.
 
-Then, enable the formatter in your `config.exs`:
+Then, enable the formatter in your `runtime.exs`:
 
 ```elixir
 config :logger, :default_handler,
   formatter: LoggerJSON.Formatters.Basic.new(metadata: [:request_id])
 ```
 
-or during runtime (eg. in your `application.ex`):
+or inside your application code (eg. in your `application.ex`):
 
 ```elixir
 formatter = LoggerJSON.Formatters.Basic.new(metadata: :all)
 :logger.update_handler_config(:default, :formatter, formatter)
 ```
 
+or inside your `config.exs` (notice that `new/1` is not available here
+and tuple format must be used):
+
+```elixir
+config :logger, :default_handler,
+  formatter: {LoggerJSON.Formatters.Basic, metadata: [:request_id]}
+```
+
 You might also want to format the log messages when migrations are running:
 
 ```elixir
@@ -57,6 +65,12 @@ config :domain, MyApp.Repo,
   start_apps_before_migration: [:logger_json]
 ```
 
+And you might want to make logging level configurable using an `LOG_LEVEL` environment variable (in `application.ex`):
+
+```elixir
+LoggerJSON.configure_log_level_from_env!()
+```
+
 Additionally, you may also be try [redirecting otp reports to Logger](https://hexdocs.pm/logger/Logger.html#module-configuration) (see "Configuration" section).
 
 ## Configuration

lib/logger_json.ex

@@ -31,16 +31,22 @@ defmodule LoggerJSON do
 
   and install it running `mix deps.get`.
 
-  Then, enable the formatter in your `config.exs`:
+  Then, enable the formatter in your `runtime.exs`:
 
       config :logger, :default_handler,
-        formatter: LoggerJSON.Formatters.Basic.new(metadata: :all)
+        formatter: LoggerJSON.Formatters.Basic.new(metadata: [:request_id])
 
-  or during runtime (eg. in your `application.ex`):
+  or inside your application code (eg. in your `application.ex`):
 
       formatter = LoggerJSON.Formatters.Basic.new(metadata: :all)
       :logger.update_handler_config(:default, :formatter, formatter)
 
+  or inside your `config.exs` (notice that `new/1` is not available here
+  and tuple format must be used):
+
+      config :logger, :default_handler,
+        formatter: {LoggerJSON.Formatters.Basic, metadata: [:request_id]}
+
   ## Configuration
 
   Configuration can be set using `new/1` helper of the formatter module,

lib/logger_json/formatter.ex

@@ -6,17 +6,35 @@ defmodule LoggerJSON.Formatter do
           | {atom(), term()}
         ]
 
+  @type config :: term()
+
   @type encoder_opts :: JSON.encoder() | [Jason.encode_opt()] | term()
 
   @doc """
-  Creates a new configuration for the formatter.
+  Initializes a new formatter configuration.
+
+  ## Compile‑time vs. Runtime Configuration
+
+  This function can’t be used in `config.exs` because that file is evaluated
+  before your application modules are compiled and loaded, so `new/1` isn’t defined yet.
+  You can only call it in `config/runtime.exs` or from your application code.
+
+  If you must set up the formatter in `config.exs`, use the tuple format:
+  the first element is the module implementing `LoggerJSON.Formatter`,
+  and the second is the options passed to `new/1`. For example:
+
+    config :logger, :default_handler,
+      formatter: {LoggerJSON.Formatters.Basic, metadata: [:request_id]}
+
+  Note that tuple‑based configs are resolved for each log entry,
+  which can increase logging overhead.
   """
-  @callback new(opts) :: {module, term()}
+  @callback new(opts :: opts()) :: {module(), config()}
 
   @doc """
   Formats a log event.
   """
-  @callback format(event :: :logger.log_event(), opts :: opts()) :: iodata()
+  @callback format(event :: :logger.log_event(), config_or_opts :: opts() | config()) :: iodata()
 
   @encoder Application.compile_env(:logger_json, :encoder, Jason)
   @encoder_protocol Application.compile_env(:logger_json, :encoder_protocol) || Module.concat(@encoder, "Encoder")

lib/logger_json/formatters/basic.ex

@@ -27,21 +27,27 @@ defmodule LoggerJSON.Formatters.Basic do
 
   @impl Formatter
   def new(opts \\ []) do
+    {__MODULE__, config(opts)}
+  end
+
+  defp config(%{} = map), do: map
+
+  defp config(opts) do
     opts = Keyword.new(opts)
     encoder_opts = Keyword.get_lazy(opts, :encoder_opts, &Formatter.default_encoder_opts/0)
     metadata_keys_or_selector = Keyword.get(opts, :metadata, [])
     metadata_selector = update_metadata_selector(metadata_keys_or_selector, @processed_metadata_keys)
     redactors = Keyword.get(opts, :redactors, [])
-    {__MODULE__, %{encoder_opts: encoder_opts, metadata: metadata_selector, redactors: redactors}}
+    %{encoder_opts: encoder_opts, metadata: metadata_selector, redactors: redactors}
   end
 
   @impl Formatter
-  def format(%{level: level, meta: meta, msg: msg}, config) do
+  def format(%{level: level, meta: meta, msg: msg}, config_or_opts) do
     %{
       encoder_opts: encoder_opts,
       metadata: metadata_selector,
       redactors: redactors
-    } = config
+    } = config(config_or_opts)
 
     message =
       format_message(msg, meta, %{

lib/logger_json/formatters/datadog.ex

@@ -52,23 +52,29 @@ defmodule LoggerJSON.Formatters.Datadog do
 
   @impl Formatter
   def new(opts \\ []) do
+    {__MODULE__, config(opts)}
+  end
+
+  defp config(%{} = map), do: map
+
+  defp config(opts) do
     opts = Keyword.new(opts)
     encoder_opts = Keyword.get_lazy(opts, :encoder_opts, &Formatter.default_encoder_opts/0)
     redactors = Keyword.get(opts, :redactors, [])
     hostname = Keyword.get(opts, :hostname, :system)
     metadata_keys_or_selector = Keyword.get(opts, :metadata, [])
     metadata_selector = update_metadata_selector(metadata_keys_or_selector, @processed_metadata_keys)
-    {__MODULE__, %{encoder_opts: encoder_opts, metadata: metadata_selector, redactors: redactors, hostname: hostname}}
+    %{encoder_opts: encoder_opts, metadata: metadata_selector, redactors: redactors, hostname: hostname}
   end
 
   @impl Formatter
-  def format(%{level: level, meta: meta, msg: msg}, config) do
+  def format(%{level: level, meta: meta, msg: msg}, config_or_opts) do
     %{
       encoder_opts: encoder_opts,
       metadata: metadata_selector,
       redactors: redactors,
       hostname: hostname
-    } = config
+    } = config(config_or_opts)
 
     message =
       format_message(msg, meta, %{

lib/logger_json/formatters/elastic.ex

@@ -145,21 +145,27 @@ defmodule LoggerJSON.Formatters.Elastic do
 
   @impl Formatter
   def new(opts \\ []) do
+    {__MODULE__, config(opts)}
+  end
+
+  defp config(%{} = map), do: map
+
+  defp config(opts) do
     opts = Keyword.new(opts)
     encoder_opts = Keyword.get_lazy(opts, :encoder_opts, &Formatter.default_encoder_opts/0)
     metadata_keys_or_selector = Keyword.get(opts, :metadata, [])
     metadata_selector = update_metadata_selector(metadata_keys_or_selector, @processed_metadata_keys)
     redactors = Keyword.get(opts, :redactors, [])
-    {__MODULE__, %{encoder_opts: encoder_opts, metadata: metadata_selector, redactors: redactors}}
+    %{encoder_opts: encoder_opts, metadata: metadata_selector, redactors: redactors}
   end
 
   @impl Formatter
-  def format(%{level: level, meta: meta, msg: msg}, config) do
+  def format(%{level: level, meta: meta, msg: msg}, config_or_opts) do
     %{
       encoder_opts: encoder_opts,
       metadata: metadata_selector,
       redactors: redactors
-    } = config
+    } = config(config_or_opts)
 
     message =
       format_message(msg, meta, %{

lib/logger_json/formatters/google_cloud.ex

@@ -110,6 +110,12 @@ defmodule LoggerJSON.Formatters.GoogleCloud do
 
   @impl Formatter
   def new(opts \\ []) do
+    {__MODULE__, config(opts)}
+  end
+
+  defp config(%{} = map), do: map
+
+  defp config(opts) do
     opts = Keyword.new(opts)
     encoder_opts = Keyword.get_lazy(opts, :encoder_opts, &Formatter.default_encoder_opts/0)
     redactors = Keyword.get(opts, :redactors, [])
@@ -119,15 +125,14 @@ defmodule LoggerJSON.Formatters.GoogleCloud do
     metadata_selector = update_metadata_selector(metadata_keys_or_selector, @processed_metadata_keys)
     reported_levels = Keyword.get(opts, :reported_levels, @default_levels_reported_as_errors)
 
-    {__MODULE__,
-     %{
-       encoder_opts: encoder_opts,
-       redactors: redactors,
-       service_context: service_context,
-       project_id: project_id,
-       metadata: metadata_selector,
-       reported_levels: reported_levels
-     }}
+    %{
+      encoder_opts: encoder_opts,
+      redactors: redactors,
+      service_context: service_context,
+      project_id: project_id,
+      metadata: metadata_selector,
+      reported_levels: reported_levels
+    }
   end
 
   defp get_default_project_id do
@@ -137,15 +142,15 @@ defmodule LoggerJSON.Formatters.GoogleCloud do
   end
 
   @impl Formatter
-  def format(%{level: level, meta: meta, msg: msg}, config) do
+  def format(%{level: level, meta: meta, msg: msg}, config_or_opts) do
     %{
       encoder_opts: encoder_opts,
       redactors: redactors,
       service_context: service_context,
       project_id: project_id,
       metadata: metadata_selector,
       reported_levels: reported_levels
-    } = config
+    } = config(config_or_opts)
 
     message =
       format_message(msg, meta, %{

lib/logger_json/redactor.ex

@@ -7,7 +7,25 @@ defmodule LoggerJSON.Redactor do
   """
 
   @doc """
-  Creates a new redactor.
+  Initializes a new redactor configuration.
+
+  ## Compile‑time vs. Runtime Configuration
+
+  This function can’t be used in `config.exs` because that file is evaluated
+  before your application modules are compiled and loaded, so `new/1` isn’t defined yet.
+  You can only call it in `config/runtime.exs` or from your application code.
+
+  If you must set up the redactor in `config.exs`, use the tuple format:
+  the first element is the module implementing `LoggerJSON.Redactor`,
+  and the second is the options passed to `new/1`. For example:
+
+    config :logger, :default_handler,
+      formatter: {LoggerJSON.Formatters.Basic, redactors: [
+        {MyRedactor, [option1: :value1]}
+      ]}
+
+  Note that tuple‑based configs are resolved for each log entry,
+  which can increase logging overhead.
   """
   @callback new(opts :: term()) :: {module(), term()}
 

mix.exs

@@ -2,7 +2,7 @@ defmodule LoggerJSON.Mixfile do
   use Mix.Project
 
   @source_url "https://github.com/Nebo15/logger_json"
-  @version "7.0.0"
+  @version "7.0.1"
 
   def project do
     [

test/logger_json/formatters/basic_test.exs

@@ -270,6 +270,16 @@ defmodule LoggerJSON.Formatters.BasicTest do
     end
   end
 
+  test "accepts opts as a tuple" do
+    :logger.update_handler_config(:default, :formatter, {Basic, metadata: :all})
+
+    assert capture_log(fn ->
+             Logger.debug("hello")
+           end)
+           |> decode_or_print_error()
+           |> Map.has_key?("message")
+  end
+
   test "reads metadata from the given application env" do
     Application.put_env(:logger_json, :test_basic_metadata_key, [:foo])
     formatter = Basic.new(metadata: {:from_application_env, {:logger_json, :test_basic_metadata_key}})