Refactor log configuration to be consistent with log doc guide

5 files changed, 362 insertions, 130 deletions

diff --git a/Makefile b/Makefile
index 9aeaf80c72..5ca29092d3 100644
--- a/Makefile
+++ b/Makefile
@@ -47,7 +47,6 @@ define PROJECT_ENV
 	    {auth_backends, [rabbit_auth_backend_internal]},
 	    {delegate_count, 16},
 	    {trace_vhosts, []},
-	    {log_levels, [{connection, info}]},
 	    {ssl_cert_login_from, distinguished_name},
 	    {ssl_handshake_timeout, 5000},
 	    {ssl_allow_poodle_attack, false},
diff --git a/priv/schema/rabbit.schema b/priv/schema/rabbit.schema
index 70351f116c..cd6d7a6781 100644
--- a/priv/schema/rabbit.schema
+++ b/priv/schema/rabbit.schema
@@ -990,80 +990,98 @@ end}.
     {datatype, string},
     {validators, ["dir_writable"]}]}.
 
-{mapping, "log.console", "lager.handlers", [
+{mapping, "log.console", "rabbit.log.console.enabled", [
     {datatype, {enum, [true, false]}}
 ]}.
+{mapping, "log.console.level", "rabbit.log.console.level", [
+    {datatype, {enum, [debug, info, notice, warning, error, critical, alert, emergency, none]}}
+]}.
 
-{mapping, "log.syslog", "lager.handlers", [
+{mapping, "log.syslog", "rabbit.log.syslog.enabled", [
     {datatype, {enum, [true, false]}}
 ]}.
-{mapping, "log.file", "lager.handlers", [
-    {datatype, [{enum, [false]}, string]}
+{mapping, "log.syslog.level", "rabbit.log.syslog.level", [
+    {datatype, {enum, [debug, info, notice, warning, error, critical, alert, emergency, none]}}
+]}.
+{mapping, "log.syslog.identity", "rabbit.log.syslog.identity", [
+    {datatype, string}
+]}.
+{mapping, "log.syslog.facility", "rabbit.log.syslog.facility", [
+    {datatype, atom}
 ]}.
 
-{mapping, "log.file.level", "lager.handlers", [
-    {datatype, {enum, [debug, info, warning, error]}}
+{mapping, "log.file", "rabbit.log.file.file", [
+    {datatype, [{enum, [false]}, string]}
 ]}.
-{mapping, "log.$handler.level", "lager.handlers", [
-    {datatype, {enum, [debug, info, warning, error]}}
+{mapping, "log.file.level", "rabbit.log.file.level", [
+    {datatype,
+        {enum, ['=debug', debug,
+                info, '!=info',
+                notice, '<=notice',
+                '<warning', warning,
+                error,
+                critical,
+                alert,
+                emergency,
+                none]}}
 ]}.
-{mapping, "log.file.rotation.date", "lager.handlers", [
+{mapping, "log.file.rotation.date", "rabbit.log.file.date", [
     {datatype, string}
 ]}.
-{mapping, "log.file.rotation.size", "lager.handlers", [
+{mapping, "log.file.rotation.size", "rabbit.log.file.size", [
     {datatype, integer}
 ]}.
-{mapping, "log.file.rotation.count", "lager.handlers", [
+{mapping, "log.file.rotation.count", "rabbit.log.file.count", [
     {datatype, integer}
 ]}.
 
-{mapping, "log.syslog.identity", "lager.handlers", [
+%% Log categories
+
+{mapping, "log.connection.level", "rabbit.log.categories.connection.level", [
+    {datatype, {enum, [debug, info, notice, warning, error, critical, alert, emergency, none]}}
+]}.
+{mapping, "log.connection.file", "rabbit.log.categories.connection.file", [
     {datatype, string}
 ]}.
-{mapping, "log.syslog.facility", "lager.handlers", [
-    {datatype, atom}
+
+{mapping, "log.channel.level", "rabbit.log.categories.channel.level", [
+    {datatype, {enum, [debug, info, notice, warning, error, critical, alert, emergency, none]}}
+]}.
+{mapping, "log.channel.file", "rabbit.log.categories.channel.file", [
+    {datatype, string}
 ]}.
 
-{translation, "lager.handlers",
-fun(Conf) ->
-    ConsoleHandler = case cuttlefish:conf_get("log.console", Conf, false) of
-        true  ->
-            ConsoleLevel = cuttlefish:conf_get("log.console.level", Conf, info),
-            [{lager_console_backend, ConsoleLevel}];
-        false -> []
-    end,
-    FileHandler = case cuttlefish:conf_get("log.file", Conf, undefined) of
-        false -> [];
-        File  ->
-            FileLevel = cuttlefish:conf_get("log.file.level", Conf, info),
-            RotationDate  = cuttlefish:conf_get("log.file.rotation.date", Conf, ""),
-            RotationSize  = cuttlefish:conf_get("log.file.rotation.size", Conf, 0),
-            RotationCount = cuttlefish:conf_get("log.file.rotation.count", Conf, 10),
-            [{lager_file_backend, [{file, File},
-                                   {level, FileLevel},
-                                   {date, RotationDate},
-                                   {size, RotationSize},
-                                   {formatter_config,
-                                        [date, " ", time, " ", color,
-                                         "[", severity, "] ",
-                                         {pid, ""},
-                                         " ", message, "\n"]},
-                                   {count, RotationCount}]}]
-    end,
-    SyslogHandler = case cuttlefish:conf_get("log.syslog", Conf, false) of
-        false -> [];
-        true  ->
-            SyslogLevel = cuttlefish:conf_get("log.syslog.level", Conf, info),
-            Identity = cuttlefish:conf_get("log.syslog.identity", Conf),
-            Facility = cuttlefish:conf_get("log.syslog.facility", Conf),
-            [{lager_syslog_backend, [Identity, Facility, SyslogLevel]}]
-    end,
-    case ConsoleHandler ++ FileHandler ++ SyslogHandler of
-        []    -> undefined;
-        Other -> Other
-    end
-end}.
+{mapping, "log.mirroring.level", "rabbit.log.categories.mirroring.level", [
+    {datatype, {enum, [debug, info, notice, warning, error, critical, alert, emergency, none]}}
+]}.
+{mapping, "log.mirroring.file", "rabbit.log.categories.mirroring.file", [
+    {datatype, string}
+]}.
+
+{mapping, "log.queue.level", "rabbit.log.categories.queue.level", [
+    {datatype, {enum, [debug, info, notice, warning, error, critical, alert, emergency, none]}}
+]}.
+{mapping, "log.queue.file", "rabbit.log.categories.queue.file", [
+    {datatype, string}
+]}.
 
+{mapping, "log.federation.level", "rabbit.log.categories.federation.level", [
+    {datatype, {enum, [debug, info, notice, warning, error, critical, alert, emergency, none]}}
+]}.
+{mapping, "log.federation.file", "rabbit.log.categories.federation.file", [
+    {datatype, string}
+]}.
+
+{mapping, "log.upgrade.level", "rabbit.log.categories.upgrade.level", [
+    {datatype, {enum, [debug, info, notice, warning, error, critical, alert, emergency, none]}}
+]}.
+{mapping, "log.upgrade.file", "rabbit.log.categories.upgrade.file", [
+    {datatype, string}
+]}.
+
+{mapping, "log.default.level", "rabbit.log.categories.default.level", [
+    {datatype, {enum, [debug, info, notice, warning, error, critical, alert, emergency, none]}}
+]}.
 
 % ===============================
 % Validators
diff --git a/scripts/rabbitmq-server b/scripts/rabbitmq-server
index 4edec5b470..27948ea6b7 100755
--- a/scripts/rabbitmq-server
+++ b/scripts/rabbitmq-server
@@ -221,8 +221,8 @@ start_rabbitmq_server() {
         -sasl errlog_type error \
         -sasl sasl_error_logger "$SASL_ERROR_LOGGER" \
         -rabbit lager_log_root "\"$RABBITMQ_LOG_BASE\"" \
-        -rabbit lager_handler "$RABBIT_LAGER_HANDLER" \
-        -rabbit lager_handler_upgrade "$RABBITMQ_LAGER_HANDLER_UPGRADE" \
+        -rabbit lager_default_file "$RABBIT_LAGER_HANDLER" \
+        -rabbit lager_upgrade_file "$RABBITMQ_LAGER_HANDLER_UPGRADE" \
         -rabbit enabled_plugins_file "\"$RABBITMQ_ENABLED_PLUGINS_FILE\"" \
         -rabbit plugins_dir "\"$RABBITMQ_PLUGINS_DIR\"" \
         -rabbit plugins_expand_dir "\"$RABBITMQ_PLUGINS_EXPAND_DIR\"" \
diff --git a/src/rabbit_lager.erl b/src/rabbit_lager.erl
index cb27eda788..36f2b159bc 100644
--- a/src/rabbit_lager.erl
+++ b/src/rabbit_lager.erl
@@ -137,28 +137,6 @@ ensure_logfile_exist(FileName) ->
         {error, Err} -> throw({error, {cannot_log_to_file, LogFile, Err}})
     end.
 
-lager_handlers(Silent) when Silent == silent; Silent == false ->
-    [];
-lager_handlers(tty) ->
-    [{lager_console_backend, info}];
-lager_handlers(FileName) when is_list(FileName) ->
-    LogFile = lager_util:expand_path(FileName),
-    case rabbit_file:ensure_dir(LogFile) of
-        ok -> ok;
-        {error, Reason} ->
-            throw({error, {cannot_log_to_file, LogFile,
-                           {cannot_create_parent_dirs, LogFile, Reason}}})
-    end,
-    [{lager_file_backend, [{file, FileName},
-                           {level, info},
-                           {formatter_config,
-                            [date, " ", time, " ", color, "[", severity, "] ",
-                             {pid, ""},
-                             " ", message, "\n"]},
-                           {date, ""},
-                           {size, 0}]}].
-
-
 ensure_lager_configured() ->
     case lager_configured() of
         false -> configure_lager();
@@ -193,36 +171,62 @@ configure_lager() ->
             end;
         _ -> ok
     end,
+    %% Set rabbit.log config variable based on environment.
+    prepare_rabbit_log_config(),
+    %% At this point we should have rabbit.log application variable
+    %% configured to generate RabbitMQ log handlers.
+    GeneratedHandlers = generate_lager_handlers(),
 
-    %% Configure the default sink/handlers.
-    Handlers0 = application:get_env(lager, handlers, undefined),
-    DefaultHandlers = lager_handlers(application:get_env(rabbit,
-                                                         lager_handler,
-                                                         tty)),
-    Handlers = case os:getenv("RABBITMQ_LOGS_source") of
-        %% There are no default handlers in rabbitmq.config, create a
-        %% configuration from $RABBITMQ_LOGS.
-        false when Handlers0 =:= undefined -> DefaultHandlers;
-        %% There are default handlers configure in rabbitmq.config, but
-        %% the user explicitely sets $RABBITMQ_LOGS; create new handlers
-        %% based on that, instead of using rabbitmq.config.
-        "environment"                      -> DefaultHandlers;
-        %% Use the default handlers configured in rabbitmq.com.
-        _                                  -> Handlers0
+    %% If there are lager handlers configured,
+    %% both lager and generate RabbitMQ handlers  are used.
+    %% This is because it's hard to decide clear preference rules.
+    %% RabbitMQ handlers can be set to [] to use only lager handlers.
+    Handlers = case application:get_env(lager, handlers, undefined) of
+        undefined -> GeneratedHandlers;
+        LagerHandlers ->
+            %% Remove handlers generated in previous starts
+            FormerRabbitHandlers = application:get_env(lager, rabbit_handlers, []),
+            GeneratedHandlers ++ remove_rabbit_handlers(LagerHandlers,
+                                                        FormerRabbitHandlers)
     end,
+
     application:set_env(lager, handlers, Handlers),
+    application:set_env(lager, rabbit_handlers, GeneratedHandlers),
 
     %% Setup extra sink/handlers. If they are not configured, redirect
     %% messages to the default sink. To know the list of expected extra
     %% sinks, we look at the 'lager_extra_sinks' compilation option.
-    Sinks0 = application:get_env(lager, extra_sinks, []),
-    Sinks1 = configure_extra_sinks(Sinks0,
-                                   [error_logger | list_expected_sinks()]),
-    %% TODO Waiting for basho/lager#303
-    %% Sinks2 = lists:keystore(error_logger_lager_event, 1, Sinks1,
-    %%                         {error_logger_lager_event,
-    %%                          [{handlers, Handlers}]}),
-    application:set_env(lager, extra_sinks, Sinks1),
+    LogConfig = application:get_env(rabbit, log, []),
+    LogLevels = application:get_env(rabbit, log_levels, []),
+    Categories = proplists:get_value(categories, LogConfig, []),
+    CategoriesConfig = case {Categories, LogLevels} of
+        {[], []} -> [];
+        {[], LogLevels} ->
+            io:format("Using deprecated config parameter 'log_levels'. "
+                      "Please update your configuration file according to: "
+                      "https://rabbitmq.com/logging.html"),
+            lists:map(fun({Name, Level}) -> {Name, [{level, Level}]} end,
+                      LogLevels);
+        {Categories, []} ->
+            Categories;
+        {Categories, LogLevels} ->
+            io:format("Using the deprecated config parameter 'log_levels' together "
+                      "with the new parameter 'categories'."
+                      " 'log_levels' will be ignored. Please remove 'log_levels' "
+                      "https://rabbitmq.com/logging.html"),
+            Categories
+    end,
+    SinkConfigs = lists:map(
+        fun({Name, Config}) ->
+            {rabbit_log:make_internal_sink_name(Name), Config}
+        end,
+        CategoriesConfig),
+    LagerSinks = application:get_env(lager, extra_sinks, []),
+    GeneratedSinks = generate_lager_sinks(
+        [error_logger_lager_event | list_expected_sinks()],
+        SinkConfigs),
+    Sinks = merge_lager_sink_handlers(LagerSinks, GeneratedSinks, []),
+    application:set_env(lager, extra_sinks, Sinks),
 
     case application:get_env(lager, error_logger_hwm) of
         undefined ->
@@ -234,27 +238,230 @@ configure_lager() ->
     end,
     ok.
 
-configure_extra_sinks(Sinks, [SinkName | Rest]) ->
-    Sink0 = proplists:get_value(SinkName, Sinks, []),
-    Sink1 = case proplists:is_defined(handlers, Sink0) of
-        false -> default_sink_config(SinkName, Sink0);
-        true  -> Sink0
+remove_rabbit_handlers(Handlers, FormerHandlers) ->
+    lists:filter(fun(Handler) ->
+        not lists:member(Handler, FormerHandlers)
+    end,
+    Handlers).
+
+generate_lager_handlers() ->
+    LogConfig = application:get_env(rabbit, log, []),
+    LogHandlersConfig = lists:keydelete(categories, 1, LogConfig),
+    generate_lager_handlers(LogHandlersConfig).
+
+generate_lager_handlers(LogHandlersConfig) ->
+    lists:flatmap(
+    fun
+        ({file, HandlerConfig}) ->
+            case proplists:get_value(file, HandlerConfig, false) of
+                false -> [];
+                FileName when is_list(FileName) ->
+                    Backend = lager_backend(file),
+                    generate_handler(Backend, HandlerConfig)
+            end;
+        ({Other, HandlerConfig}) when Other =:= console; Other =:= syslog ->
+            case proplists:get_value(enabled, HandlerConfig, false) of
+                false -> [];
+                true  ->
+                    Backend = lager_backend(Other),
+                    generate_handler(Backend,
+                                     lists:keydelete(enabled, 1, HandlerConfig))
+            end
+    end,
+    LogHandlersConfig).
+
+lager_backend(file) -> lager_file_backend;
+lager_backend(console) -> lager_console_backend;
+lager_backend(syslog) -> lager_syslog_backend.
+
+generate_handler(Backend, HandlerConfig) ->
+    [{Backend,
+        lists:ukeymerge(1, lists:ukeysort(1, HandlerConfig),
+                           lists:ukeysort(1, default_handler_config(Backend)))}].
+
+default_handler_config(lager_syslog_backend) ->
+    [{level, default_config_value(level)},
+     {identity, "rabbitmq"},
+     {facility, daemon},
+     {formatter_config, default_config_value(formatter_config)}];
+default_handler_config(lager_console_backend) ->
+    [{level, default_config_value(level)},
+     {formatter_config, default_config_value(formatter_config)}];
+default_handler_config(lager_file_backend) ->
+    [{level, default_config_value(level)},
+     {formatter_config, default_config_value(formatter_config)},
+     {date, ""},
+     {size, 0}].
+
+default_config_value(level) -> info;
+default_config_value(formatter_config) ->
+    [date, " ", time, " ", color, "[", severity, "] ",
+       {pid, ""},
+       " ", message, "\n"].
+
+prepare_rabbit_log_config() ->
+    %% If RABBIT_LOGS is not set, we should use console logger
+    DefaultFile = application:get_env(rabbit, lager_default_file, tty),
+    %% If RABBIT_UPGRADE_LOGS is not set, we should ignore it.
+    UpgradeFile = application:get_env(rabbit, lager_upgrade_file, undefined),
+    case DefaultFile of
+        false ->
+            set_env_default_log_disabled();
+        tty ->
+            set_env_default_log_console();
+        FileName when is_list(FileName) ->
+            case os:getenv("RABBITMQ_LOGS_source") of
+                %% The user explicitely sets $RABBITMQ_LOGS;
+                %% we should override a file location even
+                %% if it's set in rabbitmq.config
+                "environment" -> set_env_default_log_file(FileName, override);
+                _             -> set_env_default_log_file(FileName, keep)
+            end
+    end,
+
+    %% Upgrade log file never overrides the value set in rabbitmq.config
+    case UpgradeFile of
+        %% No special env for upgrade logs - rederect to the default sink
+        undefined -> ok;
+        %% Redirect logs to default output.
+        DefaultFile -> ok;
+        UpgradeFileName when is_list(UpgradeFileName) ->
+            set_env_upgrade_log_file(UpgradeFileName)
+    end.
+
+set_env_default_log_disabled() ->
+    %% Disabling all the logs.
+    application:set_env(rabbit, log, []).
+
+set_env_default_log_console() ->
+    LogConfig = application:get_env(rabbit, log, []),
+    ConsoleConfig = proplists:get_value(console, LogConfig, []),
+    LogConfigConsole =
+        lists:keystore(console, 1, LogConfig,
+                       {console, lists:keystore(enabled, 1, ConsoleConfig,
+                                                {enabled, true})}),
+    %% Remove the file handler - disable logging to file
+    LogConfigConsoleNoFile = lists:keydelete(file, 1, LogConfigConsole),
+    application:set_env(rabbit, log, LogConfigConsoleNoFile).
+
+set_env_default_log_file(FileName, Override) ->
+    LogConfig = application:get_env(rabbit, log, []),
+    FileConfig = proplists:get_value(file, LogConfig, []),
+    NewLogConfig = case proplists:get_value(file, FileConfig, undefined) of
+        undefined ->
+            lists:keystore(file, 1, LogConfig,
+                           {file, lists:keystore(file, 1, FileConfig,
+                                                 {file, FileName})});
+        _ConfiguredFileName ->
+            case Override of
+                override ->
+                    lists:keystore(
+                        file, 1, LogConfig,
+                        {file, lists:keystore(file, 1, FileConfig,
+                                              {file, FileName})});
+                keep ->
+                    LogConfig
+            end
+    end,
+    application:set_env(rabbit, log, NewLogConfig).
+
+set_env_upgrade_log_file(FileName) ->
+    LogConfig = application:get_env(rabbit, log, []),
+    SinksConfig = proplists:get_value(categories, LogConfig, []),
+    UpgradeSinkConfig = proplists:get_value(upgrade, SinksConfig, []),
+    FileConfig = proplists:get_value(file, SinksConfig, []),
+    NewLogConfig = case proplists:get_value(file, FileConfig, undefined) of
+        undefined ->
+            lists:keystore(
+                categories, 1, LogConfig,
+                {categories,
+                    lists:keystore(
+                        upgrade, 1, SinksConfig,
+                        {upgrade,
+                            lists:keystore(file, 1, UpgradeSinkConfig,
+                                           {file, FileName})})});
+        %% No cahnge. We don't want to override the configured value.
+        _File -> LogConfig
+    end,
+    application:set_env(rabbit, log, NewLogConfig).
+
+generate_lager_sinks(SinkNames, SinkConfigs) ->
+    lists:map(fun(SinkName) ->
+        SinkConfig = proplists:get_value(SinkName, SinkConfigs, []),
+        Level = proplists:get_value(level, SinkConfig, default_config_value(level)),
+        SinkHandlers = case proplists:get_value(file, SinkConfig, false) of
+            %% If no file defined - forward everything to the default backend
+            false ->
+                [{lager_forwarder_backend,
+                    [lager_util:make_internal_sink_name(lager), Level]}];
+            %% If a file defined - add a file backend to handlers and remove all default file backends.
+            File ->
+                DefaultGeneratedHandlers = application:get_env(lager, rabbit_handlers, []),
+                SinkFileHandlers = case proplists:get_value(lager_file_backend, DefaultGeneratedHandlers, undefined) of
+                    undefined ->
+                        %% Create a new file handler.
+                        generate_lager_handlers([{file, [{file, File}, {level, Level}]}]);
+                    FileHandler ->
+                        %% Replace a filename in the handler
+                        [{lager_file_backend,
+                            lists:ukeymerge(1,
+                                            [{file, File}, {level, Level}],
+                                            lists:ukeysort(1, FileHandler))}]
+                end,
+                %% Remove all file handlers.
+                AllLagerHandlers = application:get_env(lager, handlers, []),
+                HandlersWithoutFile = lists:filter(
+                    fun({lager_file_backend, _}) -> false;
+                       ({_, _}) -> true
+                    end,
+                    AllLagerHandlers),
+                %% Set level for handlers which are more verbose.
+                %% We don't increase verbosity in sinks so it works like forwarder backend.
+                HandlersWithoutFileWithLevel = lists:map(fun({Name, Handler}) ->
+                    case handler_level_more_verbose(Handler, Level) of
+                        true  -> {Name, lists:keystore(level, 1, Handler, {level, Level})};
+                        false -> {Name, Handler}
+                    end
+                end,
+                HandlersWithoutFile),
+
+                HandlersWithoutFileWithLevel ++ SinkFileHandlers
+        end,
+        {SinkName, [{handlers, SinkHandlers}, {rabbit_handlers, SinkHandlers}]}
     end,
-    Sinks1 = lists:keystore(SinkName, 1, Sinks, {SinkName, Sink1}),
-    configure_extra_sinks(Sinks1, Rest);
-configure_extra_sinks(Sinks, []) ->
-    Sinks.
-
-default_sink_config(rabbit_log_upgrade_lager_event, Sink) ->
-    Handlers = lager_handlers(application:get_env(rabbit,
-                                                  lager_handler_upgrade,
-                                                  tty)),
-    lists:keystore(handlers, 1, Sink, {handlers, Handlers});
-default_sink_config(_, Sink) ->
-    lists:keystore(handlers, 1, Sink,
-                   {handlers,
-                    [{lager_forwarder_backend,
-                      lager_util:make_internal_sink_name(lager)}]}).
+    SinkNames).
+
+handler_level_more_verbose(Handler, Level) ->
+    HandlerLevel = proplists:get_value(level, Handler, default_config_value(level)),
+    lager_util:level_to_num(HandlerLevel) > lager_util:level_to_num(Level).
+
+merge_lager_sink_handlers([{Name, Sink} | RestSinks], GeneratedSinks, Agg) ->
+    case lists:keytake(Name, 1, GeneratedSinks) of
+        {value, {Name, GenSink}, RestGeneratedSinks} ->
+            Handlers = proplists:get_value(handlers, Sink, []),
+            GenHandlers = proplists:get_value(handlers, GenSink, []),
+            FormerRabbitHandlers = proplists:get_value(rabbit_handlers, Sink, []),
+
+            %% Remove handlers defined in previous starts
+            ConfiguredHandlers = remove_rabbit_handlers(Handlers, FormerRabbitHandlers),
+            NewHandlers = GenHandlers ++ ConfiguredHandlers,
+            MergedSink = lists:keystore(rabbit_handlers, 1,
+                                        lists:keystore(handlers, 1, Sink,
+                                                       {handlers, NewHandlers}),
+                                        {rabbit_handlers, GenHandlers}),
+
+            merge_lager_sink_handlers(
+                RestSinks,
+                RestGeneratedSinks,
+                [{Name, MergedSink} | Agg]);
+        false ->
+            merge_lager_sink_handlers(
+                RestSinks,
+                GeneratedSinks,
+                [{Name, Sink} | Agg])
+    end;
+merge_lager_sink_handlers([], GeneratedSinks, Agg) -> GeneratedSinks ++ Agg.
+
 
 list_expected_sinks() ->
     case application:get_env(rabbit, lager_extra_sinks) of
diff --git a/test/unit_inbroker_non_parallel_SUITE.erl b/test/unit_inbroker_non_parallel_SUITE.erl
index 2af6368f34..9c7d798ecc 100644
--- a/test/unit_inbroker_non_parallel_SUITE.erl
+++ b/test/unit_inbroker_non_parallel_SUITE.erl
@@ -238,18 +238,20 @@ log_management1(_Config) ->
     %% logging directed to tty (first, remove handlers)
     ok = rabbit:stop(),
     ok = clean_logs([LogFile], Suffix),
-    ok = application:set_env(rabbit, lager_handler, tty),
+    ok = application:set_env(rabbit, lager_default_file, tty),
+    application:unset_env(rabbit, log),
     application:unset_env(lager, handlers),
     application:unset_env(lager, extra_sinks),
     ok = rabbit:start(),
     timer:sleep(200),
     rabbit_log:info("test info"),
-    [{error, enoent}] = empty_files([LogFile]),
+    [{error, enoent}] = non_empty_files([LogFile]),
 
     %% rotate logs when logging is turned off
     ok = rabbit:stop(),
     ok = clean_logs([LogFile], Suffix),
-    ok = application:set_env(rabbit, lager_handler, false),
+    ok = application:set_env(rabbit, lager_default_file, false),
+    application:unset_env(rabbit, log),
     application:unset_env(lager, handlers),
     application:unset_env(lager, extra_sinks),
     ok = rabbit:start(),
@@ -261,7 +263,8 @@ log_management1(_Config) ->
     %% cleanup
     ok = rabbit:stop(),
     ok = clean_logs([LogFile], Suffix),
-    ok = application:set_env(rabbit, lager_handler, LogFile),
+    ok = application:set_env(rabbit, lager_default_file, LogFile),
+    application:unset_env(rabbit, log),
     application:unset_env(lager, handlers),
     application:unset_env(lager, extra_sinks),
     ok = rabbit:start(),
@@ -279,7 +282,8 @@ log_management_during_startup1(_Config) ->
     %% start application with simple tty logging
     ok = rabbit:stop(),
     ok = clean_logs([LogFile], Suffix),
-    ok = application:set_env(rabbit, lager_handler, tty),
+    ok = application:set_env(rabbit, lager_default_file, tty),
+    application:unset_env(rabbit, log),
     application:unset_env(lager, handlers),
     application:unset_env(lager, extra_sinks),
     ok = rabbit:start(),
@@ -289,7 +293,8 @@ log_management_during_startup1(_Config) ->
     delete_file(NonExistent),
     delete_file(filename:dirname(NonExistent)),
     ok = rabbit:stop(),
-    ok = application:set_env(rabbit, lager_handler, NonExistent),
+    ok = application:set_env(rabbit, lager_default_file, NonExistent),
+    application:unset_env(rabbit, log),
     application:unset_env(lager, handlers),
     application:unset_env(lager, extra_sinks),
     ok = rabbit:start(),
@@ -301,7 +306,8 @@ log_management_during_startup1(_Config) ->
     delete_file(NoPermission1),
     delete_file(filename:dirname(NoPermission1)),
     ok = rabbit:stop(),
-    ok = application:set_env(rabbit, lager_handler, NoPermission1),
+    ok = application:set_env(rabbit, lager_default_file, NoPermission1),
+    application:unset_env(rabbit, log),
     application:unset_env(lager, handlers),
     application:unset_env(lager, extra_sinks),
     ok = try rabbit:start() of
@@ -326,7 +332,8 @@ log_management_during_startup1(_Config) ->
         ok                         -> ok;
         {error, lager_not_running} -> ok
     end,
-    ok = application:set_env(rabbit, lager_handler, NoPermission2),
+    ok = application:set_env(rabbit, lager_default_file, NoPermission2),
+    application:unset_env(rabbit, log),
     application:unset_env(lager, handlers),
     application:unset_env(lager, extra_sinks),
     ok = try rabbit:start() of
@@ -343,7 +350,8 @@ log_management_during_startup1(_Config) ->
     end,
 
     %% cleanup
-    ok = application:set_env(rabbit, lager_handler, LogFile),
+    ok = application:set_env(rabbit, lager_default_file, LogFile),
+    application:unset_env(rabbit, log),
     application:unset_env(lager, handlers),
     application:unset_env(lager, extra_sinks),
     ok = rabbit:start(),