Why is Logger's default level :debug?

Yes, it would be more reasonable default to use :info by default, but because of backward compatibility it needs to be :debug.

The way to structurally prevent this from happening is having :debug as a default: you noticed it, didn’t you?

I hate logging systems that hide messages by default from me.

When initially developing I want to see all the messages without having to mind about configuration.

In Membrane, we have a debug_verbose: boolean flag set via config, defaulting to false, and a corresponding debug_verbose macro. It’s intended for logs that are only useful for debugging the library itself, so we decided to hide them from the user by default.

For the regular debugs, I’d prefer if they were also disabled by default, as they’re intended for, well, debugging

What’s the bar for breaking compatibility? There’s some precedent for doing so when it prevents confusion:

feat(logger): return primary level as is, without conversion
This is breaking change, but inevitable to not confuse users.

Changing the default log level to something safer for production doesn’t seem like a huge stretch by comparison.

It would be nice to have a deprecation path. Can Logger reliably distinguish between an explicitly configured log level and falling back to its implicit :debug default? If so, it seems like reliance on the implicit default could first be deprecated, giving users who actually want :debug a chance to configure it explicitly.

Another interesting data point: Phoenix’s default production configuration sets the level to :info. If Phoenix is as widely used as I think it is, I suspect this masks the problem since most people never have to deal with the consequences of Logger’s defaults.

Yeah, I know, that is my work.

I 100% agree with you that default of :debug is wrong and should be changed, ideally to match Erlang’s :notice, as it would make a lot of stuff much easier.

Unfortunately - no. If that would be possible then I would propose that in the first place, but there is no way to detect that.

I believe that the default configuration of logger should match the production environment, not dev. Dev environment is form of special environment, and accidental leakage of private data (which may be logged in debug logs) is bigger issue IMHO.

For me and my libraries the bar is never. Breaking backward compatibility is a clear sign of code authors don’t give a dime about their users.

Couldn’t Logger.App.start/2 detect this by checking both Application.fetch_env(:logger, :level) and the preexisting :logger primary level?

If no Elixir level is configured and OTP is still at its default :notice, then Logger is about to introduce the implicit :debug. What case would make that detection incorrect?

It will not work when someone sets logger level using kernel application option. That option is not easily useable in development, but in production deployments it is more common.

Does that configuration matter here though? Logger.start wipes it out unconditionally.

elixir --erl "-kernel logger_level warning" -e '
IO.inspect(Application.get_env(:kernel, :logger_level), label: "kernel.logger_level")
IO.inspect(Application.get_env(:logger, :level), label: "Elixir Logger level")
IO.inspect(:logger.get_primary_config()[:level], label: "actual primary level")
'
kernel.logger_level: :warning
Elixir Logger level: nil
actual primary level: :debug