Allow console device to be configured

Author: José Valim

lib/ex_unit/lib/ex_unit/capture_log.ex

@@ -106,7 +106,7 @@ defmodule ExUnit.CaptureLog do
 
   @doc false
   def init_proxy(pid, opts, parent) do
-    case :gen_event.add_sup_handler(Logger, {Console, pid}, {pid, opts}) do
+    case :gen_event.add_sup_handler(Logger, {Console, pid}, {Console, [device: pid] ++ opts}) do
       :ok ->
         ref = Process.monitor(parent)
         :proc_lib.init_ack(:ok)

lib/logger/lib/logger.ex

@@ -183,6 +183,9 @@ defmodule Logger do
 
     * `:colors` - a keyword list of coloring options.
 
+    * `:device` - the device to log error messages to. Defaults to
+      `:user` but can be changed to something else such as `:standard_error`.
+
     * `:max_buffer` - maximum events to buffer while waiting
       for a confirmation from the IO device (default: 32).
       Once the buffer is full, the backend will block until

lib/logger/lib/logger/backends/console.ex

@@ -7,23 +7,26 @@ defmodule Logger.Backends.Console do
              max_buffer: nil, buffer_size: 0, buffer: [], ref: nil, output: nil]
 
   def init(:console) do
-    if Process.whereis(:user) do
-      init({:user, []})
+    config = Application.get_env(:logger, :console)
+    device = Keyword.get(config, :device, :user)
+
+    if Process.whereis(device) do
+      {:ok, init(config, %__MODULE__{})}
     else
       {:error, :ignore}
     end
   end
 
-  def init({device, opts}) do
-    {:ok, configure(device, opts, %__MODULE__{})}
+  def init({__MODULE__, opts}) when is_list(opts) do
+    config = configure_merge(Application.get_env(:logger, :console), opts)
+    {:ok, init(config, %__MODULE__{})}
   end
 
   def handle_call({:configure, options}, state) do
-    {:ok, :ok, configure(state.device, options, state)}
+    {:ok, :ok, configure(options, state)}
   end
 
-  def handle_event({_level, gl, _event}, state)
-  when node(gl) != node() do
+  def handle_event({_level, gl, _event}, state) when node(gl) != node() do
     {:ok, state}
   end
 
@@ -79,20 +82,20 @@ defmodule Logger.Backends.Console do
     Logger.compare_levels(lvl, min) != :lt
   end
 
-  defp configure(device, options, state) do
-    config =
-      Application.get_env(:logger, :console, [])
-      |> configure_merge(options)
-
-    if device === :user do
-      Application.put_env(:logger, :console, config)
-    end
+  defp configure(options, state) do
+    config = configure_merge(Application.get_env(:logger, :console), options)
+    Application.put_env(:logger, :console, config)
+    init(config, state)
+  end
 
-    format     = Logger.Formatter.compile Keyword.get(config, :format)
-    level      = Keyword.get(config, :level)
-    metadata   = Keyword.get(config, :metadata, [])
-    colors     = configure_colors(config)
+  defp init(config, state) do
+    level = Keyword.get(config, :level)
+    device = Keyword.get(config, :device, :user)
+    format = Logger.Formatter.compile Keyword.get(config, :format)
+    colors = configure_colors(config)
+    metadata = Keyword.get(config, :metadata, [])
     max_buffer = Keyword.get(config, :max_buffer, 32)
+
     %{state | format: format, metadata: Enum.reverse(metadata),
               level: level, colors: colors, device: device, max_buffer: max_buffer}
   end
@@ -124,12 +127,12 @@ defmodule Logger.Backends.Console do
     %{state | buffer: buffer, buffer_size: buffer_size + 1}
   end
 
-  defp async_io(:user, output) do
-    case Process.whereis(:user) do
+  defp async_io(name, output) when is_atom(name) do
+    case Process.whereis(name) do
       device when is_pid(device) ->
         async_io(device, output)
       nil ->
-        raise "no device registered with the name :user"
+        raise "no device registered with the name #{inspect name}"
     end
   end
 

lib/logger/lib/logger/config.ex

@@ -81,6 +81,7 @@ defmodule Logger.Config do
   def delete(@table) do
     :ets.delete(@table)
   end
+
   ## Callbacks
 
   def init(_) do

lib/logger/test/logger/backends/console_test.exs

@@ -1,11 +1,13 @@
 defmodule Logger.Backends.ConsoleTest do
   use Logger.Case
+
   require Logger
+  import ExUnit.CaptureIO
 
   setup do
     on_exit fn ->
       :ok = Logger.configure_backend(:console,
-              [format: nil, level: nil, metadata: [], colors: [enabled: false]])
+              [format: nil, device: :user, level: nil, metadata: [], colors: [enabled: false]])
     end
   end
 
@@ -24,6 +26,15 @@ defmodule Logger.Backends.ConsoleTest do
     {:ok, _} = Logger.add_backend(:console)
   end
 
+  test "may use another device" do
+    Logger.configure_backend(:console, device: :standard_error)
+
+    assert capture_io(:standard_error, fn ->
+      Logger.debug("hello")
+      Logger.flush()
+    end) =~ "hello"
+  end
+
   test "can configure format" do
     Logger.configure_backend(:console, format: "$message [$level]")