Cambiar programáticamente el nivel de registro en Log4j2

Estoy interesado en cambiar programáticamente el nivel de registro en Log4j2. Intenté mirar su documentación de configuración pero no parecía tener nada. También intenté buscar en el paquete:, org.apache.logging.log4j.core.configpero tampoco nada me pareció útil.

EDITADO según log4j2 versión 2.4 FAQ

Puede establecer el nivel de un registrador con la clase Configurador de Log4j Core. PERO tenga en cuenta que la clase Configurator no es parte de la API pública.

// org.apache.logging.log4j.core.config.Configurator;
Configurator.setLevel("com.example.Foo", Level.DEBUG);

// You can also set the root logger:
Configurator.setRootLevel(Level.DEBUG);

Fuente

EDITADO para reflejar los cambios en la API introducidos en Log4j2 versión 2.0.2

Si desea cambiar el nivel del registrador raíz, haga algo como esto:

LoggerContext ctx = (LoggerContext) LogManager.getContext(false);
Configuration config = ctx.getConfiguration();
LoggerConfig loggerConfig = config.getLoggerConfig(LogManager.ROOT_LOGGER_NAME); 
loggerConfig.setLevel(level);
ctx.updateLoggers();  // This causes all Loggers to refetch information from their LoggerConfig.

Aquí está el javadoc para LoggerConfig.

La respuesta aceptada por @slaadvak no me funcionó para Log4j2 2.8.2 . Lo siguiente hizo.

Para cambiar el registro Level universalmente use:

Configurator.setAllLevels(LogManager.getRootLogger().getName(), level);

Para cambiar el registro Levelsolo para la clase actual, use:

Configurator.setLevel(LogManager.getLogger(CallingClass.class).getName(), level);

Si desea cambiar un único nivel de registrador específico (no el registrador raíz o los registradores configurados en el archivo de configuración) puede hacer esto:

public static void setLevel(Logger logger, Level level) {
    final LoggerContext ctx = (LoggerContext) LogManager.getContext(false);
    final Configuration config = ctx.getConfiguration();

    LoggerConfig loggerConfig = config.getLoggerConfig(logger.getName());
    LoggerConfig specificConfig = loggerConfig;

    // We need a specific configuration for this logger,
    // otherwise we would change the level of all other loggers
    // having the original configuration as parent as well

    if (!loggerConfig.getName().equals(logger.getName())) {
        specificConfig = new LoggerConfig(logger.getName(), level, true);
        specificConfig.setParent(loggerConfig);
        config.addLogger(logger.getName(), specificConfig);
    }
    specificConfig.setLevel(level);
    ctx.updateLoggers();
}

Encontré una buena respuesta aquí: https://garygregory.wordpress.com/2016/01/11/changing-log-levels-in-log4j2/

Puede usar org.apache.logging.log4j.core.config.Configurator para establecer el nivel de un registrador específico.

Logger logger = LogManager.getLogger(Test.class);
Configurator.setLevel(logger.getName(), Level.DEBUG);

El enfoque programático es bastante intrusivo. Quizás debería verificar el soporte JMX brindado por Log4J2:

1. Habilite el puerto JMX en el inicio de su aplicación:

   -Dcom.sun.management.jmxremote.port = [port_num]

2. Utilice cualquiera de los clientes JMX disponibles (la JVM proporciona uno en JAVA_HOME / bin / jconsole.exe) mientras ejecuta su aplicación.

3. En JConsole, busque el bean "org.apache.logging.log4j2.Loggers"

4. Finalmente cambie el nivel de su registrador

Lo que más me gusta de esto es que no tienes que modificar tu código o configuración para administrarlo. Todo es externo y transparente.

Más información: http://logging.apache.org/log4j/2.x/manual/jmx.html

La mayoría de las respuestas asumen por defecto que el registro tiene que ser aditivo. Pero digamos que algún paquete está generando muchos registros y desea desactivar el registro solo para ese registrador en particular. Aquí está el código que usé para que funcione

    public class LogConfigManager {

    public void setLogLevel(String loggerName, String level) {
        Level newLevel = Level.valueOf(level);
        LoggerContext logContext = (LoggerContext) LogManager.getContext(false);
        Configuration configuration = logContext.getConfiguration();
        LoggerConfig loggerConfig = configuration.getLoggerConfig(loggerName);
        // getLoggerConfig("a.b.c") could return logger for "a.b" if there is no logger for "a.b.c"
        if (loggerConfig.getName().equalsIgnoreCase(loggerName)) {
            loggerConfig.setLevel(newLevel);
            log.info("Changed logger level for {} to {} ", loggerName, newLevel);
        } else {
            // create a new config.
            loggerConfig = new LoggerConfig(loggerName, newLevel, false);
            log.info("Adding config for: {} with level: {}", loggerConfig, newLevel);
            configuration.addLogger(loggerName, loggerConfig);


            LoggerConfig parentConfig = loggerConfig.getParent();
            do {
                for (Map.Entry<String, Appender> entry : parentConfig.getAppenders().entrySet()) {
                    loggerConfig.addAppender(entry.getValue(), null, null);
                }
                parentConfig = parentConfig.getParent();
            } while (null != parentConfig && parentConfig.isAdditive());
        }
        logContext.updateLoggers();
    }
}

Un caso de prueba para lo mismo

public class LogConfigManagerTest {
    @Test
    public void testLogChange() throws IOException {
        LogConfigManager logConfigManager = new LogConfigManager();
        File file = new File("logs/server.log");
        Files.write(file.toPath(), new byte[0], StandardOpenOption.TRUNCATE_EXISTING);
        Logger logger = LoggerFactory.getLogger("a.b.c");
        logger.debug("Marvel-1");
        logConfigManager.setLogLevel("a.b.c", "debug");
        logger.debug("DC-1");
        // Parent logger level should remain same
        LoggerFactory.getLogger("a.b").debug("Marvel-2");
        logConfigManager.setLogLevel("a.b.c", "info");
        logger.debug("Marvel-3");
        // Flush everything
        LogManager.shutdown();

        String content = Files.readAllLines(file.toPath()).stream().reduce((s1, s2) -> s1 + "\t" + s2).orElse(null);
        Assert.assertEquals(content, "DC-1");
    }
}

Suponiendo que el siguiente log4j2.xml está en classpath

<?xml version="1.0" encoding="UTF-8"?>
<Configuration xmlns="http://logging.apache.org/log4j/2.0/config">

    <Appenders>
        <File name="FILE" fileName="logs/server.log" append="true">
            <PatternLayout pattern="%m%n"/>
        </File>
        <Console name="STDOUT" target="SYSTEM_OUT">
            <PatternLayout pattern="%m%n"/>
        </Console>
    </Appenders>

    <Loggers>
        <AsyncLogger name="a.b" level="info">
            <AppenderRef ref="STDOUT"/>
            <AppenderRef ref="FILE"/>
        </AsyncLogger>

        <AsyncRoot level="info">
            <AppenderRef ref="STDOUT"/>
        </AsyncRoot>
    </Loggers>

</Configuration>

Una forma poco habitual que encontré para hacerlo es crear dos archivos separados con diferentes niveles de registro.
Por ejemplo. log4j2.xml y log4j-debug.xml Ahora cambie la configuración de estos archivos.
Código de muestra:

ConfigurationFactory configFactory = XmlConfigurationFactory.getInstance();
            ConfigurationFactory.setConfigurationFactory(configFactory);
            LoggerContext ctx = (LoggerContext) LogManager.getContext(false);
            ClassLoader classloader = Thread.currentThread().getContextClassLoader();
            InputStream inputStream = classloader.getResourceAsStream(logFileName);
            ConfigurationSource configurationSource = new ConfigurationSource(inputStream);

            ctx.start(configFactory.getConfiguration(ctx, configurationSource));