Help with migrating from log4j to log4j2 (we also use a slf4j -> log4j)

[paladox]

Could I have some help to migrate:

// Copyright (C) 2014 The Android Open Source Project
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

package com.google.gerrit.sshd.commands;

import static com.google.gerrit.sshd.CommandMetaData.Mode.MASTER_OR_SLAVE;

import com.google.common.base.Strings;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.Iterators;
import com.google.gerrit.common.data.GlobalCapability;
import com.google.gerrit.extensions.annotations.RequiresCapability;
import com.google.gerrit.sshd.CommandMetaData;
import com.google.gerrit.sshd.SshCommand;
import java.net.MalformedURLException;
import java.net.URI;
import org.apache.log4j.Level;
import org.apache.log4j.LogManager;
import org.apache.log4j.Logger;
import org.apache.log4j.PropertyConfigurator;
import org.apache.log4j.helpers.Loader;
import org.kohsuke.args4j.Argument;

@RequiresCapability(GlobalCapability.ADMINISTRATE_SERVER)
@CommandMetaData(
    name = "set-level",
    description = "Change the level of loggers",
    runsAt = MASTER_OR_SLAVE)
public class SetLoggingLevelCommand extends SshCommand {
  private static final String LOG_CONFIGURATION = "log4j.properties";
  private static final String JAVA_OPTIONS_LOG_CONFIG = "log4j.configuration";

  private enum LevelOption {
    ALL,
    TRACE,
    DEBUG,
    INFO,
    WARN,
    ERROR,
    FATAL,
    OFF,
    RESET,
  }

  @Argument(index = 0, required = true, metaVar = "LEVEL", usage = "logging level to set to")
  private LevelOption level;

  @Argument(index = 1, required = false, metaVar = "NAME", usage = "used to match loggers")
  private String name;

  @Override
  protected void run() throws MalformedURLException {
    enableGracefulStop();
    if (level == LevelOption.RESET) {
      reset();
    } else {
      for (Logger logger : getCurrentLoggers()) {
        if (name == null || logger.getName().contains(name)) {
          logger.setLevel(Level.toLevel(level.name()));
        }
      }
    }
  }

  private static void reset() throws MalformedURLException {
    for (Logger logger : getCurrentLoggers()) {
      logger.setLevel(null);
    }

    String path = System.getProperty(JAVA_OPTIONS_LOG_CONFIG);
    if (Strings.isNullOrEmpty(path)) {
      PropertyConfigurator.configure(Loader.getResource(LOG_CONFIGURATION));
    } else {
      PropertyConfigurator.configure(URI.create(path).toURL());
    }
  }

  @SuppressWarnings({"unchecked", "JdkObsolete"})
  private static ImmutableList<Logger> getCurrentLoggers() {
    return ImmutableList.copyOf(Iterators.forEnumeration(LogManager.getCurrentLoggers()));
  }
}

please?

I've come up with:

package com.google.gerrit.sshd.commands;

import static com.google.gerrit.sshd.CommandMetaData.Mode.MASTER_OR_SLAVE;

import com.google.gerrit.common.data.GlobalCapability;
import com.google.gerrit.extensions.annotations.RequiresCapability;
import com.google.gerrit.sshd.CommandMetaData;
import com.google.gerrit.sshd.SshCommand;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.Map;
import org.apache.logging.log4j.Level;
import org.apache.logging.log4j.core.LoggerContext;
import org.apache.logging.log4j.core.config.LoggerConfig;
import org.apache.log4j.Logger; // Log4j 1.x
import org.kohsuke.args4j.Argument;
import org.apache.logging.log4j.core.config.Configurator;

@RequiresCapability(GlobalCapability.ADMINISTRATE_SERVER)
@CommandMetaData(
    name = "set-level",
    description = "Change the level of existing loggers",
    runsAt = MASTER_OR_SLAVE)
public class SetLoggingLevelCommand extends SshCommand {

  public enum LevelOption {
    ALL, TRACE, DEBUG, INFO, WARN, ERROR, FATAL, OFF, RESET
  }

  private static final Map<String, Level> ORIGINAL_LOG4J2_LEVELS = new HashMap<>();
  private static final Map<String, org.apache.log4j.Level> ORIGINAL_LOG4J1_LEVELS = new HashMap<>();
  private static Level ORIGINAL_ROOT_LEVEL = null;
  private static boolean initialized = false;

  @Argument(index = 0, required = true, metaVar = "LEVEL", usage = "logging level to set to")
  private LevelOption level;

  @Argument(index = 1, required = false, metaVar = "NAME", usage = "used to match loggers")
  private String name;

  @Override
  protected void run() {
    enableGracefulStop();

    if (!initialized) {
      snapshotOriginalLevels();
      initialized = true;
    }

    if (level == LevelOption.RESET) {
      resetToSnapshot();
      return;
    }

    Level newLevel;
    try {
      newLevel = Level.valueOf(level.name());
    } catch (IllegalArgumentException e) {
      stderr.println("Unknown logging level: " + level);
      return;
    }

    // --- Log4j2 ---
    LoggerContext ctx = (LoggerContext) org.apache.logging.log4j.LogManager.getContext(false);
    org.apache.logging.log4j.core.config.Configuration config = ctx.getConfiguration();

    config.getLoggers().forEach((loggerName, loggerConfig) -> {
      if (!loggerName.isEmpty() && (name == null || loggerName.contains(name))) {
        loggerConfig.setLevel(newLevel);
        stdout.println("Updated Log4j2 LoggerConfig: " + loggerName + " -> " + newLevel);
      }
    });
    ctx.updateLoggers();

    // --- Log4j1 bridge ---
    for (Enumeration<?> e = org.apache.log4j.LogManager.getCurrentLoggers(); e.hasMoreElements(); ) {
      Logger logger1 = (Logger) e.nextElement();
      if (name == null || logger1.getName().contains(name)) {
        org.apache.log4j.Level lvl1 = org.apache.log4j.Level.toLevel(level.name());
        logger1.setLevel(lvl1);
        stdout.println("Updated Log4j1 Logger: " + logger1.getName() + " -> " + lvl1);
      }
    }
  }

  private static void snapshotOriginalLevels() {
    LoggerContext ctx = (LoggerContext) org.apache.logging.log4j.LogManager.getContext(false);
    org.apache.logging.log4j.core.config.Configuration config = ctx.getConfiguration();

    ORIGINAL_ROOT_LEVEL = config.getRootLogger().getLevel();

    config.getLoggers().forEach((loggerName, loggerConfig) -> {
      ORIGINAL_LOG4J2_LEVELS.put(loggerName, loggerConfig.getLevel());
    });

    for (Enumeration<?> e = org.apache.log4j.LogManager.getCurrentLoggers(); e.hasMoreElements(); ) {
      Logger logger1 = (Logger) e.nextElement();
      ORIGINAL_LOG4J1_LEVELS.put(logger1.getName(), logger1.getLevel());
    }
  }

  private static void resetToSnapshot() {
    LoggerContext ctx = (LoggerContext) org.apache.logging.log4j.LogManager.getContext(false);
    org.apache.logging.log4j.core.config.Configuration config = ctx.getConfiguration();

    config.getLoggers().forEach((loggerName, loggerConfig) -> {
      Level original = ORIGINAL_LOG4J2_LEVELS.get(loggerName);
      if (original != null) {
        loggerConfig.setLevel(original);
      }
    });
    if (ORIGINAL_ROOT_LEVEL != null) {
      config.getRootLogger().setLevel(ORIGINAL_ROOT_LEVEL);
    }
    ctx.updateLoggers();

    for (Enumeration<?> e = org.apache.log4j.LogManager.getCurrentLoggers(); e.hasMoreElements(); ) {
      Logger logger1 = (Logger) e.nextElement();
      org.apache.log4j.Level original = ORIGINAL_LOG4J1_LEVELS.get(logger1.getName());
      if (original != null) {
        logger1.setLevel(original);
      }
    }
  }
}

but it doesn't work properly. I'm not seeing the log level take effect, if the logger was created under slf4j (the logger will also only return under for (Enumeration<?> e = org.apache.log4j.LogManager.getCurrentLoggers(); e.hasMoreElements(); ) { for loggers created via slf4j). Although this works with ctx.getLoggerRegistry().getLoggers() in listing loggers, but I can't then use it to update the log level if it's created via slf4j.

E.g. I'm trying to set org.eclipse.jetty. to debug, which works, but it doesn't take effect, I don't see any logging under those channels in debug. It does under log4j if I revert back.

I migrated:

// Copyright (C) 2014 The Android Open Source Project
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

package com.google.gerrit.sshd.commands;

import static com.google.gerrit.sshd.CommandMetaData.Mode.MASTER_OR_SLAVE;

import com.google.common.collect.ImmutableList;
import com.google.common.collect.Iterators;
import com.google.gerrit.common.data.GlobalCapability;
import com.google.gerrit.extensions.annotations.RequiresCapability;
import com.google.gerrit.sshd.CommandMetaData;
import com.google.gerrit.sshd.SshCommand;
import java.util.Map;
import java.util.TreeMap;
import org.apache.log4j.LogManager;
import org.apache.log4j.Logger;
import org.kohsuke.args4j.Argument;

@RequiresCapability(GlobalCapability.ADMINISTRATE_SERVER)
@CommandMetaData(
    name = "ls-level",
    description = "list the level of loggers",
    runsAt = MASTER_OR_SLAVE)
public class ListLoggingLevelCommand extends SshCommand {

  @Argument(index = 0, required = false, metaVar = "NAME", usage = "used to match loggers")
  private String name;

  @Override
  protected void run() {
    enableGracefulStop();
    Map<String, String> logs = new TreeMap<>();
    for (Logger logger : getCurrentLoggers()) {
      if (name == null || logger.getName().contains(name)) {
        logs.put(logger.getName(), logger.getEffectiveLevel().toString());
      }
    }
    for (Map.Entry<String, String> e : logs.entrySet()) {
      stdout.println(e.getKey() + ": " + e.getValue());
    }
  }

  @SuppressWarnings({"unchecked", "JdkObsolete"})
  private static ImmutableList<Logger> getCurrentLoggers() {
    return ImmutableList.copyOf(Iterators.forEnumeration(LogManager.getCurrentLoggers()));
  }
}

to

// Copyright (C) 2014 The Android Open Source Project
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

package com.google.gerrit.sshd.commands;

import static com.google.gerrit.sshd.CommandMetaData.Mode.MASTER_OR_SLAVE;

import com.google.common.collect.ImmutableList;
import com.google.gerrit.common.data.GlobalCapability;
import com.google.gerrit.extensions.annotations.RequiresCapability;
import com.google.gerrit.sshd.CommandMetaData;
import com.google.gerrit.sshd.SshCommand;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;
import java.util.TreeMap;
import org.apache.logging.log4j.Level;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.core.Logger;
import org.apache.logging.log4j.core.LoggerContext;
import org.apache.logging.log4j.core.config.LoggerConfig;
import org.kohsuke.args4j.Argument;

@RequiresCapability(GlobalCapability.ADMINISTRATE_SERVER)
@CommandMetaData(
    name = "ls-level",
    description = "list the level of loggers",
    runsAt = MASTER_OR_SLAVE)
public class ListLoggingLevelCommand extends SshCommand {

  @Argument(index = 0, required = false, metaVar = "NAME", usage = "used to match loggers")
  private String name;

  @Override
  protected void run() {
    enableGracefulStop();
    Map<String, String> logs = new TreeMap<>();
    for (Logger logger : getAllLoggers()) {
      if (name == null || logger.getName().contains(name)) {
        logs.put(logger.getName(), getEffectiveLevel(logger));
      }
    }
    for (Map.Entry<String, String> e : logs.entrySet()) {
      if (e.getKey() != null && !e.getKey().isEmpty()) {
        stdout.println(e.getKey() + ": " + e.getValue());
      }
    }
  }

  private static ImmutableList<Logger> getAllLoggers() {
    LoggerContext ctx = (LoggerContext) LogManager.getContext(false);
    Set<String> seenNames = new HashSet<>();
    ImmutableList.Builder<Logger> builder = ImmutableList.builder();

    for (LoggerConfig lc : ctx.getConfiguration().getLoggers().values()) {
      Logger logger = ctx.getLogger(lc.getName());
      if (seenNames.add(logger.getName())) {
        builder.add(logger);
      }
    }

    ctx.getLoggerRegistry()
        .getLoggers()
        .forEach(
            logger -> {
              if (seenNames.add(logger.getName())) {
                builder.add(logger);
              }
            });

    return builder.build();
  }

  private static String getEffectiveLevel(Logger logger) {
    Level level = logger.getLevel();
    if (level != null) {
      return level.name();
    } else {
      Logger parent = logger.getParent();
      return (parent != null && parent.getLevel() != null) ? parent.getLevel().name() : "UNKNOWN";
    }
  }
}

which lists the loggers similar to log4j. I just can't get SetLoggingLevelCommand to work properly.

[paladox]

If I use:

package com.google.gerrit.sshd.commands;

import static com.google.gerrit.sshd.CommandMetaData.Mode.MASTER_OR_SLAVE;

import com.google.common.collect.ImmutableList;
import com.google.gerrit.common.data.GlobalCapability;
import com.google.gerrit.extensions.annotations.RequiresCapability;
import com.google.gerrit.sshd.CommandMetaData;
import com.google.gerrit.sshd.SshCommand;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;
import org.apache.logging.log4j.Level;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.core.Logger;
import org.apache.logging.log4j.core.LoggerContext;
import org.apache.logging.log4j.core.config.LoggerConfig;
import org.kohsuke.args4j.Argument;

@RequiresCapability(GlobalCapability.ADMINISTRATE_SERVER)
@CommandMetaData(
    name = "set-level",
    description = "Change the level of existing loggers",
    runsAt = MASTER_OR_SLAVE)
public class SetLoggingLevelCommand extends SshCommand {

  public enum LevelOption {
    ALL, TRACE, DEBUG, INFO, WARN, ERROR, FATAL, OFF, RESET
  }

  private static final Map<String, Level> ORIGINAL_LOG4J2_LEVELS = new HashMap<>();
  private static Level ORIGINAL_ROOT_LEVEL = null;
  private static boolean initialized = false;

  @Argument(index = 0, required = true, metaVar = "LEVEL", usage = "logging level to set to")
  private LevelOption level;

  @Argument(index = 1, required = false, metaVar = "NAME", usage = "used to match loggers")
  private String name;

  @Override
  protected void run() {
    enableGracefulStop();

    if (!initialized) {
      snapshotOriginalLevels();
      initialized = true;
    }

    if (level == LevelOption.RESET) {
      resetToSnapshot();
      return;
    }

    Level newLevel;
    try {
      newLevel = Level.valueOf(level.name());
    } catch (IllegalArgumentException e) {
      stderr.println("Unknown logging level: " + level);
      return;
    }

    LoggerContext ctx = (LoggerContext) LogManager.getContext(false);

    // Update all matching loggers
    for (Logger logger : getAllLoggers()) {
      if (name == null || logger.getName().contains(name)) {
        logger.setLevel(newLevel);
        stdout.println("Updated logger: " + logger.getName() + " -> " + newLevel);
      }
    }

    // Optionally update root logger
    if (name == null || name.isEmpty()) {
      ctx.getConfiguration().getRootLogger().setLevel(newLevel);
    }

    // Apply changes
    ctx.updateLoggers();
  }

  private static void snapshotOriginalLevels() {
    LoggerContext ctx = (LoggerContext) LogManager.getContext(false);
    ORIGINAL_ROOT_LEVEL = ctx.getConfiguration().getRootLogger().getLevel();

    for (Logger logger : getAllLoggers()) {
      ORIGINAL_LOG4J2_LEVELS.put(logger.getName(), logger.getLevel());
    }
  }

  private static void resetToSnapshot() {
    LoggerContext ctx = (LoggerContext) LogManager.getContext(false);

    for (Logger logger : getAllLoggers()) {
      Level original = ORIGINAL_LOG4J2_LEVELS.get(logger.getName());
      if (original != null) {
        logger.setLevel(original);
      }
    }

    if (ORIGINAL_ROOT_LEVEL != null) {
      ctx.getConfiguration().getRootLogger().setLevel(ORIGINAL_ROOT_LEVEL);
    }

    ctx.updateLoggers();
  }

  private static ImmutableList<Logger> getAllLoggers() {
    LoggerContext ctx = (LoggerContext) LogManager.getContext(false);
    Set<String> seenNames = new HashSet<>();
    ImmutableList.Builder<Logger> builder = ImmutableList.builder();

    // From configuration
    for (LoggerConfig lc : ctx.getConfiguration().getLoggers().values()) {
      Logger logger = ctx.getLogger(lc.getName());
      if (seenNames.add(logger.getName())) {
        builder.add(logger);
      }
    }

    // From registry (covers dynamically created loggers)
    ctx.getLoggerRegistry()
        .getLoggers()
        .forEach(
            logger -> {
              if (seenNames.add(logger.getName())) {
                builder.add((Logger) logger);
              }
            });

    return builder.build();
  }
}

It doesn't change the logger at all. When in set debug, it sticks at INFO.

[paladox]

https://gerrit-review.googlesource.com/c/gerrit/+/259202/ is my change for updating to log4j2.

[paladox]

I think I may have figured it out. It's due to rootConfig.addAppender(consoleAppender, Level.ERROR, null);. Setting the 2nd param to null fixed it.

[ppkarwasz]

Hi @paladox,

The only supported API for changing log levels at runtime in Log4j Core is Configurator. The simplest form is:

Configurator.setLevel(name, newLevel);

This works only if Log4j Core is the actual implementation of the Log4j API. Since that might not always be the case, it’s good practice to guard the call:

try {
  Configurator.setLevel(name, newLevel);
} catch (LinkageError | ClassCastException e) {
  // Log4j Core is not available or not the active implementation
}

What this does:

1. Retrieves (or creates) a LoggerConfig for name.
2. Updates its level.
3. Propagates the configuration change to all affected loggers (any logger without a more specific config inherits this new level).

About your current code

config.getLoggers().forEach((loggerName, loggerConfig) -> {
  if (!loggerName.isEmpty() && (name == null || loggerName.contains(name))) {
    loggerConfig.setLevel(newLevel);
    stdout.println("Updated Log4j2 LoggerConfig: " + loggerName + " -> " + newLevel);
  }
});
ctx.updateLoggers();

This approach differs from Configurator in two important ways:

1. It does not create a new LoggerConfig if one doesn’t already exist for name.
2. It overrides the level of all explicitly configured child loggers.

For example, if foo has no config but foo.bar and foo.baz do, then:

• foo.bar and foo.baz levels will be overridden.
• foo itself will remain unchanged (inheriting from root).

Adjusting whole hierarchies

If you want to update an entire logger hierarchy, Configurator.setAllLevels is the intended API:

try {
  Configurator.setAllLevels(name, newLevel);
} catch (LinkageError | ClassCastException e) {
  // Log4j Core is not available or not the active implementation
}

Key difference from Log4j 1

This is probably the root cause of your migration issues:

• In Log4j 1, the Logger object itself held both runtime state and configuration, and parent loggers always existed (foo.bar implied foo).

• In Log4j 2 Core, loggers and their configuration are separate (see Architecture). Only:

  • loggers you actually request in code, and
  • configurations explicitly defined in your config file

are created.

So, to affect loggers that don’t have an explicit configuration, you need to use the Configurator API rather than directly iterating over existing LoggerConfigs.

Note

A Logger Admin API is planned (see apache/logging-admin) to provide a standard, implementation-independent way of managing logger levels. However, development capacity is currently limited, so this is not yet available.

[paladox]

Ah thanks! My current code before I saw this is:

// Copyright (C) 2014 The Android Open Source Project
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

package com.google.gerrit.sshd.commands;

import static com.google.gerrit.sshd.CommandMetaData.Mode.MASTER_OR_SLAVE;

import com.google.gerrit.common.data.GlobalCapability;
import com.google.gerrit.extensions.annotations.RequiresCapability;
import com.google.gerrit.sshd.CommandMetaData;
import com.google.gerrit.sshd.SshCommand;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;
import org.apache.logging.log4j.Level;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.core.LoggerContext;
import org.apache.logging.log4j.core.config.LoggerConfig;
import org.kohsuke.args4j.Argument;

@RequiresCapability(GlobalCapability.ADMINISTRATE_SERVER)
@CommandMetaData(
    name = "set-level",
    description = "Change the level of loggers",
    runsAt = MASTER_OR_SLAVE)
public class SetLoggingLevelCommand extends SshCommand {

  private enum LevelOption {
    ALL,
    TRACE,
    DEBUG,
    INFO,
    WARN,
    ERROR,
    FATAL,
    OFF,
    RESET
  }

  private static final Map<String, Level> ORIGINAL_LEVELS = new HashMap<>();
  private static final Set<String> ORIGINAL_LOGGER_NAMES = new HashSet<>();
  private static Level ORIGINAL_ROOT_LEVEL = null;
  private static boolean initialized = false;

  @Argument(index = 0, required = true, metaVar = "LEVEL", usage = "logging level to set to")
  private LevelOption level;

  @Argument(index = 1, required = false, metaVar = "NAME", usage = "used to match loggers")
  private String name;

  @Override
  protected void run() {
    enableGracefulStop();

    if (!initialized) {
      copyOriginalLevels();
      initialized = true;
    }

    if (level == LevelOption.RESET) {
      reset();
      return;
    }

    final Level newLevel;
    try {
      newLevel = Level.valueOf(level.name());
    } catch (IllegalArgumentException e) {
      stderr.println("Unknown logging level: " + level);
      return;
    }

    LoggerContext ctx = (LoggerContext) LogManager.getContext(false);
    org.apache.logging.log4j.core.config.Configuration config = ctx.getConfiguration();

    for (Map.Entry<String, LoggerConfig> entry : config.getLoggers().entrySet()) {
      String loggerName = entry.getKey();
      if (loggerName.isEmpty()) continue;
      if (name == null || loggerName.contains(name)) {
        entry.getValue().setLevel(newLevel);
      }
    }

    ctx.getLoggerRegistry()
        .getLoggers()
        .forEach(
            logger -> {
              String loggerName = logger.getName();
              if (loggerName.isEmpty()) return;
              if (name == null || loggerName.contains(name)) {
                LoggerConfig lc = config.getLoggerConfig(loggerName);
                if (!lc.getName().equals(loggerName)) {
                  LoggerConfig newLc = new LoggerConfig(loggerName, newLevel, true);
                  config.addLogger(loggerName, newLc);
                } else {
                  lc.setLevel(newLevel);
                }
              }
            });

    ctx.updateLoggers();
  }

  private static void copyOriginalLevels() {
    LoggerContext ctx = (LoggerContext) LogManager.getContext(false);
    org.apache.logging.log4j.core.config.Configuration config = ctx.getConfiguration();

    ORIGINAL_ROOT_LEVEL = config.getRootLogger().getLevel();

    for (Map.Entry<String, LoggerConfig> e : config.getLoggers().entrySet()) {
      String loggerName = e.getKey();
      ORIGINAL_LOGGER_NAMES.add(loggerName);
      ORIGINAL_LEVELS.put(loggerName, e.getValue().getLevel());
    }
  }

  private static void reset() {
    LoggerContext ctx = (LoggerContext) LogManager.getContext(false);
    org.apache.logging.log4j.core.config.Configuration config = ctx.getConfiguration();

    for (LoggerConfig lc : config.getLoggers().values()) {
      lc.setLevel(null);
    }
    if (ORIGINAL_ROOT_LEVEL != null) {
      config.getRootLogger().setLevel(null);
    }

    for (Map.Entry<String, Level> e : ORIGINAL_LEVELS.entrySet()) {
      LoggerConfig lc = config.getLoggers().get(e.getKey());
      if (lc != null) {
        lc.setLevel(e.getValue());
      }
    }
    if (ORIGINAL_ROOT_LEVEL != null) {
      config.getRootLogger().setLevel(ORIGINAL_ROOT_LEVEL);
    }

    ctx.updateLoggers();
  }
}

[paladox]

For some reason doing:

// Copyright (C) 2014 The Android Open Source Project
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

package com.google.gerrit.sshd.commands;

import static com.google.gerrit.sshd.CommandMetaData.Mode.MASTER_OR_SLAVE;

import com.google.gerrit.common.data.GlobalCapability;
import com.google.gerrit.extensions.annotations.RequiresCapability;
import com.google.gerrit.sshd.CommandMetaData;
import com.google.gerrit.sshd.SshCommand;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;
import org.apache.logging.log4j.Level;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.core.LoggerContext;
import org.apache.logging.log4j.core.config.LoggerConfig;
import org.kohsuke.args4j.Argument;

@RequiresCapability(GlobalCapability.ADMINISTRATE_SERVER)
@CommandMetaData(
    name = "set-level",
    description = "Change the level of loggers",
    runsAt = MASTER_OR_SLAVE)
public class SetLoggingLevelCommand extends SshCommand {

  private enum LevelOption {
    ALL,
    TRACE,
    DEBUG,
    INFO,
    WARN,
    ERROR,
    FATAL,
    OFF,
    RESET
  }

  private static final Map<String, Level> ORIGINAL_LEVELS = new HashMap<>();
  private static final Set<String> ORIGINAL_LOGGER_NAMES = new HashSet<>();
  private static Level ORIGINAL_ROOT_LEVEL = null;
  private static boolean initialized = false;

  @Argument(index = 0, required = true, metaVar = "LEVEL", usage = "logging level to set to")
  private LevelOption level;

  @Argument(index = 1, required = false, metaVar = "NAME", usage = "used to match loggers")
  private String name;

  @Override
  protected void run() {
    enableGracefulStop();

    if (!initialized) {
      copyOriginalLevels();
      initialized = true;
    }

    if (level == LevelOption.RESET) {
      reset();
      return;
    }

    final Level newLevel;
    try {
      newLevel = Level.valueOf(level.name());
    } catch (IllegalArgumentException e) {
      stderr.println("Unknown logging level: " + level);
      return;
    }

    //LoggerContext ctx = (LoggerContext) LogManager.getContext(false);
    //org.apache.logging.log4j.core.config.Configuration config = ctx.getConfiguration();

    /*for (Map.Entry<String, LoggerConfig> entry : config.getLoggers().entrySet()) {
      String loggerName = entry.getKey();
      if (loggerName.isEmpty()) continue;
      if (name == null || loggerName.contains(name)) {
        entry.getValue().setLevel(newLevel);
      }
    }*/

    org.apache.logging.log4j.core.config.Configurator.setLevel(name, newLevel);
    /*ctx.getLoggerRegistry()
        .getLoggers()
        .forEach(
            logger -> {
              String loggerName = logger.getName();
              if (loggerName.isEmpty()) return;
              if (name == null || loggerName.contains(name)) {
                org.apache.logging.log4j.core.config.Configurator.setLevel(loggerName, newLevel);
                /*LoggerConfig lc = config.getLoggerConfig(loggerName);
                if (!lc.getName().equals(loggerName)) {
                  LoggerConfig newLc = new LoggerConfig(loggerName, newLevel, true);
                  config.addLogger(loggerName, newLc);
                } else {
                  lc.setLevel(newLevel);
                }*/
              //}
            //});*/

    //ctx.updateLoggers();
  }

  private static void copyOriginalLevels() {
    LoggerContext ctx = (LoggerContext) LogManager.getContext(false);
    org.apache.logging.log4j.core.config.Configuration config = ctx.getConfiguration();

    ORIGINAL_ROOT_LEVEL = config.getRootLogger().getLevel();

    for (Map.Entry<String, LoggerConfig> e : config.getLoggers().entrySet()) {
      String loggerName = e.getKey();
      ORIGINAL_LOGGER_NAMES.add(loggerName);
      ORIGINAL_LEVELS.put(loggerName, e.getValue().getLevel());
    }
  }

  private static void reset() {
    LoggerContext ctx = (LoggerContext) LogManager.getContext(false);
    org.apache.logging.log4j.core.config.Configuration config = ctx.getConfiguration();

    for (LoggerConfig lc : config.getLoggers().values()) {
      lc.setLevel(null);
    }
    if (ORIGINAL_ROOT_LEVEL != null) {
      config.getRootLogger().setLevel(null);
    }

    for (Map.Entry<String, Level> e : ORIGINAL_LEVELS.entrySet()) {
      LoggerConfig lc = config.getLoggers().get(e.getKey());
      if (lc != null) {
        lc.setLevel(e.getValue());
      }
    }
    if (ORIGINAL_ROOT_LEVEL != null) {
      config.getRootLogger().setLevel(ORIGINAL_ROOT_LEVEL);
    }

    ctx.updateLoggers();
  }
}

And then setting debug to all, doesn't apply it to the log4j 1.x / slf4j loggers. Any ideas @ppkarwasz ?

Another question is reset. With log4j 1.x we did:

  private static void reset() throws MalformedURLException {
    for (Logger logger : getCurrentLoggers()) {
      logger.setLevel(null);
    }

    String path = System.getProperty(JAVA_OPTIONS_LOG_CONFIG);
    if (Strings.isNullOrEmpty(path)) {
      PropertyConfigurator.configure(Loader.getResource(LOG_CONFIGURATION));
    } else {
      PropertyConfigurator.configure(URI.create(path).toURL());
    }
  }

  @SuppressWarnings({"unchecked", "JdkObsolete"})
  private static ImmutableList<Logger> getCurrentLoggers() {
    return ImmutableList.copyOf(Iterators.forEnumeration(LogManager.getCurrentLoggers()));
  }

which when I convert to log4j 2 doesn't really work properly. Setting the log level to null, causes all the loggers to be INFO and not the original. Unless you have to store an original in the Map now? (I found a workaround per the above code, just was wondering if was doing anything wrong, as preferably I don't really want to store a map of the original loggers).

[paladox]

I've done the following:

    if (name == null) {
      Configurator.setAllLevels("", newLevel);
    } else {
      LoggerContext ctx = (LoggerContext) LogManager.getContext(false);
      ctx.getLoggerRegistry()
          .getLoggers()
          .forEach(
              logger -> {
                String loggerName = logger.getName();
                if (loggerName.contains(name)) {
                  Configurator.setLevel(loggerName, newLevel);
                }
              });
    }

Per your recommendation to use the Configurator class. Does that look good to you?

This should work with log4j 1.x & slf4j alongside log4j2 (fetching all the loggers).

For resetting, I have:

  private static void reset() {
    LoggerContext ctx = (LoggerContext) LogManager.getContext(false);
    org.apache.logging.log4j.core.config.Configuration config = ctx.getConfiguration();

    ctx.getLoggerRegistry()
        .getLoggers()
        .forEach(
            logger -> {
              Level original = ORIGINAL_LEVELS.get(logger.getName());
              if (original != null) {
                Configurator.setLevel(logger.getName(), original);
              }
            });

    if (ORIGINAL_ROOT_LEVEL != null) {
      config.getRootLogger().setLevel(ORIGINAL_ROOT_LEVEL);
    }

    ctx.updateLoggers();
  }

We don't set a configuration file (we allow someone to set one, but don't actively use it as a default). Do you know how I can convert:

  private static void reset() throws MalformedURLException {
    for (Logger logger : getCurrentLoggers()) {
      logger.setLevel(null);
    }

    String path = System.getProperty(JAVA_OPTIONS_LOG_CONFIG);
    if (Strings.isNullOrEmpty(path)) {
      PropertyConfigurator.configure(Loader.getResource(LOG_CONFIGURATION));
    } else {
      PropertyConfigurator.configure(URI.create(path).toURL());
    }
  }

  @SuppressWarnings({"unchecked", "JdkObsolete"})
  private static ImmutableList<Logger> getCurrentLoggers() {
    return ImmutableList.copyOf(Iterators.forEnumeration(LogManager.getCurrentLoggers()));
  }

to log4j2? I did my best to, but it seems setting log levels to null, only makes for example a logger that had WARN as its default, go to INFO. Unlike in log4j1 when it worked. I found a workaround in creating a original logger map, but preferably if there's a way to match log4j, I'd prefer that.

https://gist.github.com/paladox/ee30542a176c3d95fe337264974090c0 is the full code for the new updated code and https://github.com/GerritCodeReview/gerrit/blob/master/java/com/google/gerrit/sshd/commands/SetLoggingLevelCommand.java for the original.

[ppkarwasz]

If I do:

if (name == null) {
  org.apache.logging.log4j.core.config.Configurator.setAllLevels("", newLevel);
} else {
  LoggerContext ctx = (LoggerContext) LogManager.getContext(false);
  //org.apache.logging.log4j.core.config.Configuration config = ctx.getConfiguration();
  ctx.getLoggerRegistry()
      .getLoggers()
      .forEach(
         logger -> {
           String loggerName = logger.getName();
           if (loggerName.contains(name)) {
             org.apache.logging.log4j.core.config.Configurator.setLevel(loggerName, newLevel);
           }
         });
}

that works. Or do you recommend something else?

Configurator.setAllLevels should work with any logger name, not just "". Are you saying it doesn’t behave that way in your case?

[paladox]

Well I want to configure all the loggers in root to x if name isn't specified. Although I guess it could be:

      LoggerContext ctx = (LoggerContext) LogManager.getContext(false);
      ctx.getLoggerRegistry()
          .getLoggers()
          .forEach(
              logger -> {
                String loggerName = logger.getName();
                if (name == null || loggerName.contains(name)) {
                  Configurator.setLevel(loggerName, newLevel);
                }
              });

[ppkarwasz]

Do you know how I can convert:

  private static void reset() throws MalformedURLException {
    for (Logger logger : getCurrentLoggers()) {
      logger.setLevel(null);
    }

    String path = System.getProperty(JAVA_OPTIONS_LOG_CONFIG);
    if (Strings.isNullOrEmpty(path)) {
      PropertyConfigurator.configure(Loader.getResource(LOG_CONFIGURATION));
    } else {
      PropertyConfigurator.configure(URI.create(path).toURL());
    }
  }

  @SuppressWarnings({"unchecked", "JdkObsolete"})
  private static ImmutableList<Logger> getCurrentLoggers() {
    return ImmutableList.copyOf(Iterators.forEnumeration(LogManager.getCurrentLoggers()));
  }

to log4j2?

Log4j 1.x didn’t have a separate Configuration object, loading a config file just mutated the global state in place. That’s why your old code needed to “reset” loggers by setting their levels back to null before reapplying the configuration.

In Log4j 2, Configuration is a standalone object. To “reset,” you don’t need to touch individual loggers; you simply build a fresh configuration and replace the old one:

LoggerContext context = (LoggerContext) LogManager.getContext(false);

String path = System.getProperty(JAVA_OPTIONS_LOG_CONFIG);
URI configLocation = Strings.isNullOrEmpty(path)
        ? Loader.getResource(LOG_CONFIGURATION).toURI()
        : URI.create(path);

// Build a new configuration
Configuration newConfig =
        ConfigurationFactory.getInstance().getConfiguration(context, null, configLocation);

// Replace the old configuration
context.reconfigure(newConfig);

This reinitializes the logging system with the new configuration. All logger levels and appenders are reset to what the new config specifies, no manual logger.setLevel(null) loop is needed anymore.

Note

The Configuration object in Log4j 2 is still mutable, which is why utilities like Configurator.setLevel work. However, we don’t recommend making broader changes to the live configuration: if done in the wrong order, you may encounter race conditions or even lose log events. For more advanced use cases, prefer building a new configuration as described in programmatic configuration.

[paladox]

Oh, thank you so much! That worked! My new code: https://gist.github.com/paladox/a04421f52c2667c6873297b1a886e030

[paladox]

@ppkarwasz do you know why the following won't work properly: https://gist.github.com/paladox/149db37be61a1f0f412b96d7c140a18e. It causes [2025-09-06 20:09:22,346] [sshd-SshDaemon[1c5fc](port=22)-nio2-thread-5] WARN org.apache.sshd.server.session.ServerUserAuthService []: handleUserAuthRequestMessage(ServerSessionImpl[null@/[0:0:0:0:0:0:0:1]:56951]) Failed (IllegalStateException) to authenticate using factory method=publickey: AsyncAppender SshAsync is not active which I traced to void onLogin() { Log4jLogEvent entry = log("LOGIN FROM " + session.get().getRemoteAddressAsString()); if (async != null) async.append(entry); audit(context.get(), "0", "LOGIN"); } but all of them return that anyways. It's just that function that now prevents ssh.

The original code is https://github.com/GerritCodeReview/gerrit/blob/master/java/com/google/gerrit/sshd/SshLog.java.

[ppkarwasz]

ctx.addPropertyChangeListener(
          evt -> {
            if ("config".equals(evt.getPropertyName())) {
              synchronized (lock) {
                enableLogging();
              }
            }
          });

The PropertyChangeListener is called each time updateLoggers() is called, but your listener also calls updateLoggers(), so I would expect a stack overflow to happen here.

For number 1 do you mean create a xml file for sshlog to define things? Wouldn't reconfigure just get rid of that, because we use log4j2.xml?

Yes, calling LoggerContext.reconfigure() is only able to load a single configuration at a time, but you can create a merged configuration programmatically:

ConfigurationFactory configFactory = ConfigurationFactory.getInstance();
AbstractConfiguration commonConfig = (AbstractConfiguration) 
        configFactory.getConfiguration(ctx, null, URI.create("classpath:log4j2-common.xml")); 
AbstractConfiguration sshConfig = (AbstractConfiguration) 
        configFactory.getConfiguration(ctxl, null, URI.create("classpath:log4j2-ssh.xml")); 
ctx.reconfigure(new CompositeConfiguration(Arrays.asList(commonConfig, sshConfig)));

[paladox]

What about something like:

  private static final AtomicBoolean reconfiguring = new AtomicBoolean(false);

  @Inject
  SshLog(
      final Provider<SshSession> session,
      final Provider<Context> context,
      SystemLog systemLog,
      @GerritServerConfig Config config,
      LogConfig logConfig,
      GroupAuditService auditService) {
    this.session = session;
    this.context = context;
    this.auditService = auditService;
    this.systemLog = systemLog;
    this.json = logConfig.isJsonLogging();
    this.text = logConfig.isTextLogging();

    if (config.getBoolean("sshd", "requestLog", true)) {
      initLogger();

      // Prevent stack overflow on Log4j reconfiguration
      LoggerContext ctx = (LoggerContext) LogManager.getContext(false);
      ctx.addPropertyChangeListener(
          evt -> {
            if ("config".equals(evt.getPropertyName())) {
              initLogger();
            }
          });
    }
  }

  /** Initialize the SSH logger appenders safely */
  private void initLogger() {
    synchronized (lock) {
      if (reconfiguring.get()) return;
      reconfiguring.set(true);
      try {
        LoggerContext ctx = (LoggerContext) LogManager.getContext(false);
        Configuration cfg = ctx.getConfiguration();

        // Stop previous appender if exists
        if (async != null) {
          async.stop();
          async = null;
        }

        List<AppenderRef> refList = new ArrayList<>();

        if (text) {
          String name = LOG_NAME;
          if (!cfg.getAppenders().containsKey(name)) {
            cfg.addAppender(systemLog.createAsyncAppender(name, new SshLogLayout()));
          }
          refList.add(AppenderRef.createAppenderRef(name, null, null));
        }

        if (json) {
          String name = LOG_NAME + JSON_SUFFIX;
          if (!cfg.getAppenders().containsKey(name)) {
            cfg.addAppender(systemLog.createAsyncAppender(name, new SshLogJsonLayout()));
          }
          refList.add(AppenderRef.createAppenderRef(name, null, null));
        }

        AppenderRef[] refs = refList.toArray(new AppenderRef[0]);

        async =
            AsyncAppender.newBuilder()
                .setName("SshAsync")
                .setAppenderRefs(refs)
                .setConfiguration(cfg)
                .build();

        async.start();
        cfg.addAppender(async);
        ctx.updateLoggers();
      } finally {
        reconfiguring.set(false);
      }
    }
  }

[paladox]

Is there an alternative tho that doesn't require a file (since we have more dynamic ones)? Since I do things programmatically. Or is the way I found, the only way.

[paladox]

@ppkarwasz how would I move this to using the logger instead of appender (if things will work with reconfigure())? And how would I get it to still use AsyncAppender rather how can I rewrite this (and how do I get logger to log to sshd_log rather than to both that and error_log and how do I get it so I can use a log layout)? I have another use case that does things dynamically: https://gist.github.com/paladox/2a8cc90bfff35639f2319a4101db2e27 (original code: https://github.com/GerritCodeReview/gerrit/blob/master/java/com/google/gerrit/server/util/PluginLogFile.java)

[ppkarwasz]

Hi @paladox,

On your current approach

In your current code you stop async before creating a new one. That means:

• For a short time no appender is available at all.
• Even worse, the async field is temporarily null.

A safer pattern is to build the replacement first and only swap the reference at the very end. That way you never expose a “gap” where logging calls see no appender.

Also note: since you’re not attaching the AsyncAppender to any logger, there’s no need to register it with the active LoggerContext configuration. The only reason you need a Configuration is because the AsyncAppender builder requires it in order to look up its referenced appenders. In this case you can use your own private NullConfiguration instance instead of modifying the shared context.

Programmatic configuration options

If the goal is to combine a file-based configuration with some programmatically defined components, there are two main approaches:

1. CompositeConfiguration + ConfigurationBuilder (recommended)

   • Use CompositeConfiguration to merge your static file with a dynamically built config.
   • Build the dynamic part using ConfigurationBuilder.
   • Advantage: this doesn’t require instantiating or managing any Core components yourself: you’re just describing what should exist, and Log4j Core builds and wires everything.
   • Limitation: attributes are provided as strings, so it’s not 100% type-safe, though the builder offers type-safe helpers for the common ones.

2. Custom ConfigurationFactory

   • Implement your own ConfigurationFactory that loads a standard config (delegating to an existing factory) and then applies programmatic modifications.
   • Advantage: fully type-safe, since you’re working directly with configuration objects. The lifecycle is handled for you because the configuration is only started after the factory returns it.
   • Useful if you want strict control over configuration composition without relying on string-based attributes.