How to log to stderr?

Questions / Help
,
1

I am trying to write log messages to stderr (rather than to stdout). However, the obvious thing (device: :standard_error) seems to have no effect. In the following one-liner the log output is still written to stdout.

$ elixir -e 'require Logger; Logger.configure_backend(:console, device: :standard_error); Logger.error("why stdout?")' 2>/dev/null 

20:41:11.210 [error] why stdout?

Am I missing something obvious?

I wanted to create a script that writes something to stdout and then that something is piped into another program. Hence the logger must write to stderr (rather than stdout).

Koszal

2

Is this also true when running the application as a daemon?

3

Not sure what you mean by running as a daemon - if I enclose the calls to the logger in a module and then spawn a function that does the loging then yes - it still goes to stdout.

4

The Logger docs have a section on configuration
which mentions:

“See :logger_std_h for all relevant configuration, including overload protection.”

That page includes bits on how to set the type of device the logger writes to:

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

Maybe that helps?

5

Thanks for the links. I did try a few things but could not get it to work. It looks more involved so I need to put some time aside and investigate how Erlang logging works.

I understand that simple scripts is not where BEAM shines but I thought that would be a fun way to play with the language (and also to pitch it to my colleagues)

Koszal

6

You want a fun way to play, try livebook, the scripts (especially in that format) are not useful and don’t show any of the capabilities of erlang/OTP.

7

@Koszal could you get away with IO instead? Since you only wanted it for scripting anyways → 

eflogger [master] $ cat stderr.exs
IO.puts("stdout")
IO.puts(:stderr,"stderr")
eflogger [master] $ elixir stderr.exs > stdout.log 2> stderr.log
eflogger [master] $ cat stdout.log
stdout
eflogger [master] $ cat stderr.log
stderr
eflogger [master] $
8

Gleaned from this post, the following seemed to work for me:

# in config/config.exs
import Config

config :logger, :console,
  format: "$date $time [$level] $message\n",
  device: :standard_error
9

btw, your original sample works as intended for me it seems like:

dnscheck on  main [!] via  
→  elixir -e 'require Logger; Logger.configure_backend(:console, device: :standard_error); Logger.error("why stdout?")' 2>scr/delme

dnscheck on  main [!] via  
→  cat scr/delme

18:55:55.984 [error] why stdout?

Perhaps due to elixer/erlang versions being used?
I’m on:

→  iex
Erlang/OTP 25 [erts-13.1.2] [source] [64-bit] [smp:4:4] [ds:4:4:10] [async-threads:1] [jit:ns]

Interactive Elixir (1.14.2) - press Ctrl+C to exit (type h() ENTER for help)
10

could you get away with IO instead?

Sure - but that’s not the point : )

Koszal

11

Hm
 That’s interesting!

I am on newer versions - one compiled by hand (Linux), another installed by a package manager (MacOS).

Maybe something changed in the Logger setup and the documentation I looked at was out of date?

Koszal

12

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.

3 Likes
13

So I suppose using stderr only for Logger.error is out of the question?

14

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

2 Likes
15

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).

1 Like
16

Some erlang can be used as well I think for logging to stderr.

elixir -e ':io.format(:standard_error, "my error", [])'
17

something got lost in translation here

This is how it appears on my screen:

image

18

I took the freedom to edit some code fences in.

As this:

some text [ ]

renders into

some text

Where the is a clickable checkbox.

2 Likes
19

And the doublequotes turn into “fancy-pants doublequotes” (to use the technical term).
:upside_down_face:

20

True, there are more ways that lead to Rome than one. But OP’s question was specifically about the route employing the facilities offered by Elixir’s Logger.

1 Like