log4java - log4j2 root logger

Cambiar el nivel de registro mediante programación en Log4j2

Question

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

Answer 1

El enfoque programático es bastante intrusivo. Tal vez deberías verificar el soporte JMX dado por Log4J2:

1. Habilite el puerto JMX en el inicio de la 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 busca el bean "org.apache.logging.log4j2.Loggers"

4. Finalmente cambia el nivel de tu registrador

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

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

Answer 2

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 para un registrador específico.

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

Answer 3

La mayoría de las respuestas de forma predeterminada suponen que el registro debe ser aditivo. Pero diga que algunos paquetes generan muchos registros y desea desactivar el registro solo para ese registrador en particular. Aquí está el código que utilicé 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 el 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");
    }
}

Asumiendo 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>

Answer 4

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

Para cambiar el Level registro universalmente use:

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

Para cambiar el Level registro solo para la clase actual, use:

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

Answer 5

Si desea cambiar un solo nivel de registrador específico (no el registrador de 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();
}

Answer 6

Una forma inusual que encontré hacer es crear dos archivos separados con diferente nivel 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));

Answer 7

EDITADO según log4j2 versión 2.4 Preguntas frecuentes

Puede establecer el nivel de un registrador con el Configurador de clases 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);

Source

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

Si desea cambiar el nivel del registrador de 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.

Here está el javadoc para LoggerConfig.