There have been indeed some changes to Elixir’s Logger since v1.15.0:

[Logger] The :console configuration has been deprecated in favor of :default_formatter
[Logger] The :backends configuration has been deprecated in favor of Logger.add_handlers/1

Logger now uses :logger’s default handler and refers to the logger_std_h documentation, which states:

type = io:standard_io/0 | io:standard_error/0 | file | {device, io:device/0 } - Specifies the log destination.

The value is set when the handler is added, and it cannot be changed in runtime.

Defaults to standard_io, unless parameter file is given, in which case it defaults to file.

So once the require Logger is excuted in the one-liner, the default handler will have been added and its device cannot be changed during runtime. And looking at the actual
configuration of the default handler:

elixir -e 'require Logger; :logger.get_handler_config(:default) |> IO.inspect(); Logger.error("why stdout?")' 2>scr/delme
{:ok,
 %{
   id: :default,
   module: :logger_std_h,
   config: %{
     type: :standard_io,
     burst_limit_enable: true,
     drop_mode_qlen: 200,
     flush_qlen: 1000,
     sync_mode_qlen: 10,
     overload_kill_restart_after: 5000,
     burst_limit_max_count: 500,
     burst_limit_window_time: 1000,
     overload_kill_enable: false,
     overload_kill_mem_size: 3000000,
     overload_kill_qlen: 20000,
     filesync_repeat_interval: :no_repeat
   },
   level: :all,
   filters: [remote_gl: {&:logger_filters.remote_gl/2, :stop}],
   filter_default: :log,
   formatter: {Logger.Formatter,
    %Logger.Formatter{
      template: ["\n", :time, " ", :metadata, "[", :level, "] ", :message, "\n"],
      truncate: 8096,
      metadata: [],
      colors: %{
        error: :red,
        enabled: true,
        info: :normal,
        warning: :yellow,
        debug: :cyan,
        notice: :normal,
        alert: :red,
        critical: :red,
        emergency: :red
      },
      utc_log?: false
    }}
 }}

08:53:01.187 [error] why stdout?

it is indeed using stdio.

It is possible. You just need to add additional Logger backend that will filter messages to level :error or higher and output to stderr.

I took the freedom to edit some code fences in.

As this:

some text [ ]

renders into

some text

Where the is a clickable checkbox.

My goal was not to write to STDERR - rather to have the standard logger behave sensibly. (And I understand my definition of sensible may not match typical BEAM use cases).

Maybe I’ll provide more context:

I am writing a tiny app that will talk to a legacy XML API (a get-to-know Elixir/LiveView project).
I started with the XML API interface. Request payloads are rendered using EEx templates. I liked how I could pattern match to select the appropriate template and then render it injecting required values. Once I had that ready I whipped up an .exs script that reads key value pairs (from System.argv). I could fire it off and render requests to STDOUT. The next step was piping to | curl -d@- -XPOST http://... The server complained about illegal input. After a bit of poking I realized log messages went to STDOUT rather than STDERR so I was feeding not only XML but logger output to the remote host.

And hence my question about having logger write to STDOUT.

The whole Logger business is somewhat of Dark Magic to me, but like @hauleth said, it looks like you would need to:

• filter out level :error for the default_handler (which logs to stdio by default)
• add a second handler, filter out all but level :error and config it to log to stderr

(assuming the default handler is not logging to file).