feat: add logging options to use :level instead of deprecated :log_level (#779)

Author: yordis

lib/tesla/middleware/logger.ex

@@ -76,7 +76,8 @@ defmodule Tesla.Middleware.Logger do
 
   ## Options
 
-  - `:log_level` - custom function for calculating log level (see below)
+  - `:level` - custom function for calculating log level or atom for fixed level (see below)
+  - `:log_level` - (deprecated) custom function for calculating log level (see below)
   - `:filter_headers` - sanitizes sensitive headers before logging in debug mode (see below)
   - `:debug` - use `Logger.debug/2` to log request/response details
   - `:format` - custom string template or function for log message (see below)
@@ -120,7 +121,43 @@ defmodule Tesla.Middleware.Logger do
   - `:warn` or `:warning` - for 3xx responses
   - `:info` - for 2xx responses
 
-  You can customize this setting by providing your own `log_level/1` function:
+  You can customize this setting by providing your own level function that accepts
+  both success and error cases:
+
+  ```elixir
+  defmodule MyClient do
+    def client do
+      Tesla.client([
+        {Tesla.Middleware.Logger, level: &my_level/1}
+      ])
+    end
+
+    def my_level({:ok, env}) do
+      case env.status do
+        404 -> :info
+        _ -> :default
+      end
+    end
+
+    def my_level({:error, _reason}) do
+      :error
+    end
+  end
+  ```
+
+  Or provide a fixed log level:
+
+  ```elixir
+  defmodule MyClient do
+    def client do
+      Tesla.client([
+        {Tesla.Middleware.Logger, level: :debug}
+      ])
+    end
+  end
+  ```
+
+  You can also use the deprecated `log_level` option (will show a deprecation warning):
 
   ```elixir
   defmodule MyClient do
@@ -139,6 +176,13 @@ defmodule Tesla.Middleware.Logger do
   end
   ```
 
+  To disable the deprecation warning for `:log_level`, add this to your config:
+
+  ```elixir
+  # config/config.exs
+  config :tesla, disable_log_level_warning: true
+  ```
+
   ## Logger Debug output
 
   `Tesla` will use `Logger.debug/2` to log request & response details using
@@ -233,28 +277,54 @@ defmodule Tesla.Middleware.Logger do
     response
   end
 
-  defp log_level({:error, _}, _), do: :error
+  defp log_level(response, config) do
+    log_level_option = Keyword.get(config, :log_level)
+    level_option = Keyword.get(config, :level)
+
+    cond do
+      log_level_option != nil and level_option != nil ->
+        raise ArgumentError, "cannot provide both :log_level and :level options"
+
+      log_level_option != nil ->
+        IO.warn(":log_level option is deprecated, use :level option instead")
+
+        apply_level_function(response, &legacy_log_level_wrapper(log_level_option, &1))
 
-  defp log_level({:ok, env}, config) do
-    case Keyword.get(config, :log_level) do
-      nil ->
-        default_log_level(env)
+      level_option != nil ->
+        apply_level_function(response, level_option)
 
-      fun when is_function(fun) ->
-        case fun.(env) do
-          :default -> default_log_level(env)
-          warning when warning in [:warn, :warning] -> @warning_level
-          level -> level
-        end
+      true ->
+        default_response_log_level(response)
+    end
+  end
 
-      warning when warning in [:warn, :warning] ->
-        @warning_level
+  defp apply_level_function(response, fun) when is_function(fun) do
+    case fun.(response) do
+      :default -> default_response_log_level(response)
+      warning when warning in [:warn, :warning] -> @warning_level
+      level -> level
+    end
+  end
 
-      atom when is_atom(atom) ->
-        atom
+  defp apply_level_function(_response, atom) when is_atom(atom) do
+    case atom do
+      warning when warning in [:warn, :warning] -> @warning_level
+      level -> level
     end
   end
 
+  # Wrapper function to adapt old log_level functions to the new response tuple format
+  defp legacy_log_level_wrapper(log_level_function, {:ok, env}) do
+    log_level_function.(env)
+  end
+
+  defp legacy_log_level_wrapper(_log_level_function, {:error, _}) do
+    :error
+  end
+
+  defp default_response_log_level({:error, _}), do: :error
+  defp default_response_log_level({:ok, env}), do: default_log_level(env)
+
   @spec default_log_level(Tesla.Env.t()) :: log_level
   def default_log_level(env) do
     cond do

test/tesla/middleware/logger_test.exs

@@ -223,6 +223,122 @@ defmodule Tesla.Middleware.LoggerTest do
     end
   end
 
+  describe "with level" do
+    defmodule ClientWithLevel do
+      use Tesla
+
+      plug Tesla.Middleware.Logger, level: &level/1
+
+      defp level({:ok, env}) do
+        cond do
+          env.status == 404 -> :info
+          env.status >= 500 -> :error
+          true -> :debug
+        end
+      end
+
+      defp level({:error, _reason}) do
+        :warn
+      end
+
+      adapter fn env ->
+        case env.url do
+          "/connection-error" ->
+            {:error, :econnrefused}
+
+          "/server-error" ->
+            {:ok, %{env | status: 500, body: "server error"}}
+
+          "/not-found" ->
+            {:ok, %{env | status: 404, body: "not found"}}
+
+          "/ok" ->
+            {:ok, %{env | status: 200, body: "ok"}}
+        end
+      end
+    end
+
+    test "connection error logs at warn level" do
+      log = capture_log(fn -> ClientWithLevel.get("/connection-error") end)
+      assert log =~ "[warning] GET /connection-error -> error: :econnrefused"
+    end
+
+    test "server error logs at error level" do
+      log = capture_log(fn -> ClientWithLevel.get("/server-error") end)
+      assert log =~ "[error] GET /server-error -> 500"
+    end
+
+    test "not found logs at info level" do
+      log = capture_log(fn -> ClientWithLevel.get("/not-found") end)
+      assert log =~ "[info] GET /not-found -> 404"
+    end
+
+    test "ok logs at debug level" do
+      Logger.configure(level: :debug)
+      log = capture_log(fn -> ClientWithLevel.get("/ok") end)
+      assert log =~ "[debug] GET /ok -> 200"
+    end
+  end
+
+  describe "with level as atom" do
+    defmodule ClientWithFixedLevel do
+      use Tesla
+
+      plug Tesla.Middleware.Logger, level: :warn
+
+      adapter fn env ->
+        case env.url do
+          "/any-request" ->
+            {:ok, %{env | status: 200, body: "ok"}}
+        end
+      end
+    end
+
+    test "always logs at the specified level" do
+      log = capture_log(fn -> ClientWithFixedLevel.get("/any-request") end)
+      assert log =~ "[warning] GET /any-request -> 200"
+    end
+  end
+
+  describe "conflicting level options" do
+    test "raises error when both :level and :log_level are provided" do
+      assert_raise ArgumentError, "cannot provide both :log_level and :level options", fn ->
+        client =
+          Tesla.client(
+            [
+              {Tesla.Middleware.Logger,
+               level: :info, log_level: &Tesla.Middleware.Logger.default_log_level/1}
+            ],
+            fn env ->
+              {:ok, %{env | status: 200, body: "ok"}}
+            end
+          )
+
+        Tesla.get(client, "/test")
+      end
+    end
+  end
+
+  describe "deprecation warning configuration" do
+    test "log_level deprecation warning shows by default" do
+      # Capture both log and warnings
+      output =
+        ExUnit.CaptureIO.capture_io(:stderr, fn ->
+          client =
+            Tesla.client(
+              [
+                {Tesla.Middleware.Logger, log_level: fn _env -> :info end}
+              ],
+              fn env -> {:ok, %{env | status: 200}} end
+            )
+
+          Tesla.get(client, "/test")
+        end)
+
+      assert output =~ ":log_level option is deprecated"
+    end
+  end
+
   alias Tesla.Middleware.Logger.Formatter
 
   defmodule CompileMod do

test/tesla/middleware/retry_test.exs

@@ -351,7 +351,7 @@ defmodule Tesla.Middleware.RetryTest do
     finish_time = :os.system_time(:millisecond)
 
     # need to allow some time for the request handling; should be small relative to max_delay to minimize probability of false negatives
-    allowed_execution_ms = 100
+    allowed_execution_ms = 200
 
     %{retries: retries, start_time: start_time} = Agent.get(LaggyAdapter, fn state -> state end)