Add missing erlang handler

Author: José Valim

lib/logger/lib/logger/erlang_handler.ex

@@ -0,0 +1,133 @@
+defmodule Logger.ErlangHandler do
+  @moduledoc false
+
+  @doc """
+  Hook required by `:logger`.
+  """
+  def log(%{meta: %{domain: [:otp, :sasl | _]}}, %{sasl_reports?: false}) do
+    :ok
+  end
+
+  def log(%{meta: %{domain: [:supervisor_report]}}, %{sasl_reports?: false}) do
+    :ok
+  end
+
+  def log(%{level: level, msg: msg, meta: erl_meta}, _config) do
+    level = erlang_level_to_elixir_level(level)
+
+    Logger.bare_log(level, fn ->
+      try do
+        meta = extract_metadata(erl_meta)
+
+        case msg do
+          {:string, string} ->
+            {string, meta}
+
+          {:report, %{label: label, report: report} = complete} when map_size(complete) == 2 ->
+            translate(level, :report, {label, report}, meta, erl_meta)
+
+          {:report, %{label: {:error_logger, _}, format: format, args: args}} ->
+            translate(level, :format, {format, args}, meta, erl_meta)
+
+          {:report, report} ->
+            translate(level, :report, {:logger, report}, meta, erl_meta)
+
+          {format, args} ->
+            translate(level, :format, {format, args}, meta, erl_meta)
+        end
+      rescue
+        e ->
+          [
+            "Failure while translating Erlang's logger event\n",
+            Exception.format(:error, e, System.stacktrace())
+          ]
+      end
+    end)
+  end
+
+  defp erlang_level_to_elixir_level(:emergency), do: :error
+  defp erlang_level_to_elixir_level(:alert), do: :error
+  defp erlang_level_to_elixir_level(:critical), do: :error
+  defp erlang_level_to_elixir_level(:error), do: :error
+  defp erlang_level_to_elixir_level(:warning), do: :warn
+  defp erlang_level_to_elixir_level(:notice), do: :info
+  defp erlang_level_to_elixir_level(:info), do: :info
+  defp erlang_level_to_elixir_level(:debug), do: :debug
+
+  defp extract_metadata(map) do
+    metadata = []
+
+    metadata =
+      case map do
+        %{mfa: {mod, fun, arity}} -> [module: mod, function: form_fa(fun, arity)] ++ metadata
+        _ -> metadata
+      end
+
+    metadata =
+      case map do
+        %{file: file, line: line} -> [file: List.to_string(file), line: line] ++ metadata
+        _ -> metadata
+      end
+
+    metadata =
+      case map do
+        %{pid: pid} -> [pid: pid] ++ metadata
+        _ -> metadata
+      end
+
+    metadata
+  rescue
+    _ -> []
+  end
+
+  defp form_fa(fun, arity) do
+    Atom.to_string(fun) <> "/" <> Integer.to_string(arity)
+  end
+
+  @doc """
+  Shared translation convenience.
+  """
+  def translate(level, kind, data, meta, erl_meta) do
+    %{
+      level: min_level,
+      truncate: truncate,
+      translators: translators
+    } = Logger.Config.__data__()
+
+    case translate(translators, min_level, level, kind, data, meta) do
+      :none -> {translate_fallback(kind, data, erl_meta, truncate), meta}
+      other -> other
+    end
+  end
+
+  defp translate([{mod, fun} | t], min_level, level, kind, data, meta) do
+    case apply(mod, fun, [min_level, level, kind, data]) do
+      {:ok, chardata, transdata} -> {chardata, Keyword.merge(meta, transdata)}
+      {:ok, chardata} -> {chardata, meta}
+      :skip -> :skip
+      :none -> translate(t, min_level, level, kind, data, meta)
+    end
+  end
+
+  defp translate([], _min_level, _level, _kind, _data, _meta) do
+    :none
+  end
+
+  defp translate_fallback(:report, {:logger, data}, %{report_cb: callback} = meta, truncate) do
+    translate_fallback(:format, callback.(data), meta, truncate)
+  end
+
+  defp translate_fallback(:format, {format, args}, _meta, truncate) do
+    format
+    |> Logger.Utils.scan_inspect(args, truncate)
+    |> :io_lib.build_text()
+  end
+
+  defp translate_fallback(:report, {_type, %{} = data}, _meta, _truncate) do
+    Kernel.inspect(Map.to_list(data))
+  end
+
+  defp translate_fallback(:report, {_type, data}, _meta, _truncate) do
+    Kernel.inspect(data)
+  end
+end

lib/logger/test/logger/erlang_handler_test.exs

@@ -0,0 +1,109 @@
+defmodule Logger.ErlangHandlerTest do
+  use Logger.Case
+  @moduletag :logger
+
+  defmodule CustomTranslator do
+    def t(:debug, :info, :format, {'hello: ~p', [:ok]}) do
+      :skip
+    end
+
+    def t(:debug, :info, :format, {'world: ~p', [:ok]}) do
+      {:ok, "rewritten"}
+    end
+
+    def t(:debug, :info, :report, {:logger, %{hello: :ok}}) do
+      :skip
+    end
+
+    def t(:debug, :info, :report, {:logger, %{world: :ok}}) do
+      {:ok, "rewritten"}
+    end
+
+    def t(:debug, :info, :report, {:logger, %{error: error}}) do
+      raise(error)
+    end
+
+    def t(_, _, _, _) do
+      :none
+    end
+  end
+
+  test "add_translator/1 and remove_translator/1 for error_logger" do
+    assert Logger.add_translator({CustomTranslator, :t})
+
+    assert capture_log(fn ->
+             :error_logger.info_msg('hello: ~p', [:ok])
+           end) == ""
+
+    assert capture_log(fn ->
+             :error_logger.info_msg('world: ~p', [:ok])
+           end) =~ "[info]  rewritten"
+  after
+    assert Logger.remove_translator({CustomTranslator, :t})
+  end
+
+  test "add_translator/1 and remove_translator/1 for logger formats" do
+    assert Logger.add_translator({CustomTranslator, :t})
+
+    assert capture_log(fn ->
+             :logger.info('hello: ~p', [:ok])
+           end) == ""
+
+    assert capture_log(fn ->
+             :logger.info('world: ~p', [:ok])
+           end) =~ "[info]  rewritten"
+
+    assert capture_log(fn ->
+             :logger.info(%{hello: :ok})
+           end) == ""
+
+    assert capture_log(fn ->
+             :logger.info(%{world: :ok})
+           end) =~ "[info]  rewritten"
+  after
+    assert Logger.remove_translator({CustomTranslator, :t})
+  end
+
+  test "handles translation error" do
+    assert Logger.add_translator({CustomTranslator, :t})
+
+    message = capture_log(fn -> :logger.info(%{error: "oops"}) end)
+    assert message =~ "[info]  Failure while translating Erlang's logger event\n"
+    assert message =~ "** (RuntimeError) oops\n"
+  after
+    assert Logger.remove_translator({CustomTranslator, :t})
+  end
+
+  test "converts Erlang metadata" do
+    Logger.configure_backend(:console, metadata: [:file, :line, :module, :function])
+
+    message =
+      capture_log(fn ->
+        :logger.info("ok", %{file: 'file.erl', line: 13, mfa: {Foo, :bar, 3}})
+      end)
+
+    assert message =~ "module=Foo"
+    assert message =~ "function=bar/3"
+    assert message =~ "file=file.erl"
+    assert message =~ "line=13"
+  after
+    Logger.configure_backend(:console, metadata: [])
+  end
+
+  test "uses reporting callback with Elixir inspection" do
+    assert capture_log(fn ->
+             callback = fn %{hello: :world} -> {"~p~n", [:formatted]} end
+             :logger.info(%{hello: :world}, %{report_cb: callback})
+           end) =~ "[info]  :formatted"
+  end
+
+  test "converts log levels" do
+    assert capture_log(fn -> :logger.emergency('ok') end) =~ "[error] ok"
+    assert capture_log(fn -> :logger.alert('ok') end) =~ "[error] ok"
+    assert capture_log(fn -> :logger.critical('ok') end) =~ "[error] ok"
+    assert capture_log(fn -> :logger.error('ok') end) =~ "[error] ok"
+    assert capture_log(fn -> :logger.warning('ok') end) =~ "[warn]  ok"
+    assert capture_log(fn -> :logger.info('ok') end) =~ "[info]  ok"
+    assert capture_log(fn -> :logger.debug('ok') end) =~ "[debug] ok"
+  end
+end