Cómo inicializar log4j correctamente?

Si bien configurar log4j correctamente es ideal para proyectos "reales", es posible que desee una solución rápida y sucia, por ejemplo, si solo está probando una nueva biblioteca.

Si es así, una llamada al método estático

org.apache.log4j.BasicConfigurator.configure();

Configurará el registro básico en la consola, y los mensajes de error desaparecerán.

Si usted acaba de deshacerse de todo (por ejemplo, si usted está en las pruebas)

org.apache.log4j.BasicConfigurator.configure(new NullAppender());

Según Página de preguntas frecuentes de Apache Log4j :

¿Por qué veo una advertencia sobre "No se han encontrado apéndices para logger" y "Configure log4j correctamente"?

Esto ocurre cuando los archivos de configuración por defecto log4j.properties y log4j.xml no se pueden encontrar y la aplicación no realiza ninguna configuración explícita. log4j utiliza Thread.getContextClassLoader().getResource() para localizar los archivos de configuración predeterminados y no comprueba directamente el sistema de archivos. Conocer la ubicación adecuada para colocar log4j. properties o log4j.xml requiere comprender la estrategia de búsqueda del cargador de clases en uso. log4j no proporciona una configuración predeterminada ya que la salida a la consola o al sistema de archivos puede estar prohibida en algunos entornos.

Básicamente la advertencia No se pudo encontrar ningún apéndice para logger significa que está utilizando log4j sistema de registro, pero no ha añadido ningún Appenders (como FileAppender, ConsoleAppender,SocketAppender, SyslogAppender, etc.) en su archivo de configuración o falta el archivo de configuración.

Hay tres formas de configurar log4j: con un archivo de propiedades (log4j.properties), con un archivo XML y a través de código Java (rootLogger.addAppender(new NullAppender());).

log4j.properties

Si tiene un archivo de propiedades presente (por ejemplo, al instalar Solr), debe colocar este archivo dentro de su directorio classpath.

Classpath

Aquí hay algunas sugerencias de comandos en Linux como determinar su classpath valor:

$ echo $CLASSPATH
$ ps wuax | grep -i classpath
$ grep -Ri classpath /etc/tomcat? /var/lib/tomcat?/conf /usr/share/tomcat?

O desde Java: System.getProperty("java.class.path").

Log4j XML

A continuación se muestra un archivo de configuración XML básico para log4j en formato XML:

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE log4j:configuration SYSTEM "log4j.dtd">

<log4j:configuration xmlns:log4j="http://jakarta.apache.org/log4j/">
  <appender name="console" class="org.apache.log4j.ConsoleAppender"> 
    <param name="Target" value="System.out"/> 
    <layout class="org.apache.log4j.PatternLayout"> 
      <param name="ConversionPattern" value="%-5p %c{1} - %m%n"/> 
    </layout> 
  </appender> 

  <root> 
    <priority value ="debug" /> 
    <appender-ref ref="console" /> 
  </root>

</log4j:configuration>

Tomcat

Si estás usando Tomcat, puedes colocar tu log4j.properties en la carpeta: /usr/share/tomcat?/lib/ o /var/lib/tomcat?/webapps/*/WEB-INF/lib/.

Solr

Para la referencia, el archivo Solr default log4j.properties se parece a:

#  Logging level
solr.log=logs/
log4j.rootLogger=INFO, file, CONSOLE

log4j.appender.CONSOLE=org.apache.log4j.ConsoleAppender

log4j.appender.CONSOLE.layout=org.apache.log4j.PatternLayout
log4j.appender.CONSOLE.layout.ConversionPattern=%-4r [%t] %-5p %c %x \u2013 %m%n

#- size rotation with log cleanup.
log4j.appender.file=org.apache.log4j.RollingFileAppender
log4j.appender.file.MaxFileSize=4MB
log4j.appender.file.MaxBackupIndex=9

#- File to log to and log format
log4j.appender.file.File=${solr.log}/solr.log
log4j.appender.file.layout=org.apache.log4j.PatternLayout
log4j.appender.file.layout.ConversionPattern=%-5p - %d{yyyy-MM-dd HH:mm:ss.SSS}; %C; %m\n

log4j.logger.org.apache.zookeeper=WARN
log4j.logger.org.apache.hadoop=WARN

# set to INFO to enable infostream log messages
log4j.logger.org.apache.solr.update.LoggingInfoStream=OFF

¿Por qué log4j no puede encontrar mi archivo de propiedades en una aplicación J2EE o WAR?

La respuesta corta: el las clases log4j y el archivo de propiedades no están dentro del alcance del mismo classloader.

Log4j solo usa el mecanismo predeterminado Class.forName() para cargar clases. Los recursos se manejan de manera similar. Vea la documentación de java.lang.ClassLoader para más detalles.

Por lo tanto, si tiene problemas, intente cargar la clase o el recurso usted mismo. Si no puedes encontrarlo, tampoco log4j.;)

Véase también:

• Breve introducción a log4j en Apache site
• Apache: Servicios de registro: FAQ en el sitio Apache

Encuentre un log4j. properties o log4j.xml en línea que tiene un appender raíz, y ponerlo en su classpath.

### direct log messages to stdout ###
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.Target=System.out
log4j.appender.stdout.layout=org.apache.log4j.SimpleLayout
log4j.rootLogger=debug, stdout

Se conectará a la consola. Prefiero iniciar sesión en un archivo para que pueda investigar después.

log4j.appender.file=org.apache.log4j.RollingFileAppender
log4j.appender.file.maxFileSize=100KB
log4j.appender.file.maxBackupIndex=5
log4j.appender.file.File=test.log
log4j.appender.file.threshold=debug
log4j.appender.file.layout=org.apache.log4j.PatternLayout
log4j.appender.file.layout.ConversionPattern=%d{ABSOLUTE} %5p %c{1}:%L - %m%n
log4j.rootLogger=debug,file

Aunque para las aplicaciones de registro detallado, 100KB generalmente necesita aumentarse a 1MB o 10MB, especialmente para la depuración.

Personalmente configuré varios registradores, y configuré el registrador raíz para advertir o nivel de error en lugar de depurar.

Puede establecer la ubicación de su log4j. properties desde dentro de su aplicación java mediante:

org.apache.log4j.PropertyConfigurator.configure(file/location/log4j.properties)

Más información está disponible aquí: https://logging.apache.org/log4j/1.2/manual.html

Otra forma de hacerlo sin poner el archivo de propiedad en el classpath, es establecer la propiedad desde el código java directamente. Aquí está el código de ejemplo.

public class Log4JSample {

public static void main(String[] args) {
    Properties properties=new Properties();
    properties.setProperty("log4j.rootLogger","TRACE,stdout,MyFile");
    properties.setProperty("log4j.rootCategory","TRACE");

    properties.setProperty("log4j.appender.stdout",     "org.apache.log4j.ConsoleAppender");
    properties.setProperty("log4j.appender.stdout.layout",  "org.apache.log4j.PatternLayout");
    properties.setProperty("log4j.appender.stdout.layout.ConversionPattern","%d{yyyy/MM/dd HH:mm:ss.SSS} [%5p] %t (%F) - %m%n");

    properties.setProperty("log4j.appender.MyFile", "org.apache.log4j.RollingFileAppender");
    properties.setProperty("log4j.appender.MyFile.File", "my_example.log");
    properties.setProperty("log4j.appender.MyFile.MaxFileSize", "100KB");
    properties.setProperty("log4j.appender.MyFile.MaxBackupIndex", "1");
    properties.setProperty("log4j.appender.MyFile.layout",  "org.apache.log4j.PatternLayout");
    properties.setProperty("log4j.appender.MyFile.layout.ConversionPattern","%d{yyyy/MM/dd HH:mm:ss.SSS} [%5p] %t (%F) - %m%n");

    PropertyConfigurator.configure(properties);

    Logger logger = Logger.getLogger("MyFile");

    logger.fatal("This is a FATAL message.");
    logger.error("This is an ERROR message.");
    logger.warn("This is a WARN message.");
    logger.info("This is an INFO message.");
    logger.debug("This is a DEBUG message.");
    logger.trace("This is a TRACE message.");
}

}

Puede configurar el nivel de registro usando setLevel().

Los niveles son útiles para establecer fácilmente el tipo de información que desea que el programa muestre.

Por ejemplo:

Logger.getRootLogger().setLevel(Level.WARN); //will not show debug messages

El conjunto de niveles posibles son:

TRAZA,

DEPURAR,

INFO,

ADVERTIR,

ERROR y

FATAL

De acuerdo con Manual de Servicios de registro

import org.apache.log4j.BasicConfigurator;

Llame a este método

BasicConfigurator.configure();

Para habilitar -Dlog4j.debug, voy a Sistema, Configuración avanzada del sistema, Variables de entorno y establezco la variable del sistema _JAVA_OPTIONS a -Dlog4j.debug.

¿En qué estás desarrollando? Estás usando Apache Tomcat?

log4j.appender.CONSOLE=org.apache.log4j.ConsoleAppender
log4j.appender.CONSOLE.target=System.out
log4j.appender.CONSOLE.layout=org.apache.log4j.PatternLayout
log4j.appender.CONSOLE.layout.ConversionPattern=%d{yyyyMMdd HH:mm:ss.SSS} [[%5p] %c{1} [%t]] %m%n

Tengo propiedades como esta en una aplicación Java mía.

Mi log4j se arregló por debajo del archivo de propiedades:

## direct log messages to stdout ###
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.Target=System.out
log4j.appender.stdout.layout=org.apache.log4j.SimpleLayout
log4j.rootLogger=debug, stdout
log4j.appender.file=org.apache.log4j.RollingFileAppender
log4j.appender.file.maxFileSize=100KB
log4j.appender.file.maxBackupIndex=5
log4j.appender.file.File=./logs/test.log
log4j.appender.file.threshold=debug
log4j.appender.file.layout=org.apache.log4j.PatternLayout
log4j.appender.file.layout.ConversionPattern=%d{ABSOLUTE} %5p %c{1}:%L - %m%n
log4j.rootLogger=debug,file

He creado el archivo log4j.properties en la carpeta resources junto a hibernar.cfg.archivo xml y lo rellenó con el texto siguiente:

log4j.rootLogger=INFO, CONSOLE

log4j.appender.CONSOLE=org.apache.log4j.ConsoleAppender
log4j.appender.CONSOLE.layout=org.apache.log4j.PatternLayout
log4j.appender.CONSOLE.layout.ConversionPattern=%d{ABSOLUTE} %-5p [%c{1}:%L] %m%n

Ahora me deshice de las advertencias y errores

Simplemente, cree log4j.properties en la carpeta src/main/assembly. Dependiendo de si desea que los mensajes de registro se muestren en la consola o en el archivo, modifique el archivo. Lo siguiente va a mostrar sus mensajes en la consola.

# Root logger option
log4j.rootLogger=INFO, stdout

# Direct log messages to stdout
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.Target=System.out
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%d{yyyy-MM-dd HH:mm:ss} %-5p %c{1}:%L - %m%n

Como se explicó anteriormente hay 2 enfoques

El primero es simplemente agregar esta línea a su método principal:

BasicConfigurator.configure();

El segundo enfoque es agregar este archivo log4j.properties estándar a su classpath:

Mientras toma el segundo enfoque, debe asegurarse de inicializar el archivo correctamente.

Eg.

Properties props = new Properties();

props.load(new FileInputStream("log4j property file path"));

props.setProperty("log4j.appender.File.File", "Folder where you want to store log files/" + "File Name");

Asegúrese de crear la carpeta necesaria para almacenar los archivos de registro.

Intente establecer el atributo debug en el nodo log4j:configuration en true.

<log4j:configuration xmlns:log4j="http://jakarta.apache.org/log4j/" debug="true">

Imprime información a medida que se lee el archivo de configuración y se utiliza para configurar el entorno log4j. Es posible que tenga más detalles para resolver su problema.

API de registro - La API de registro de Java facilita el servicio y mantenimiento de software en los sitios del cliente mediante la producción de informes de registro adecuados para el análisis por parte de los usuarios finales, administradores de sistemas, ingenieros de servicio de campo y equipos de desarrollo de software. Las API de registro capturan información como fallos de seguridad, errores de configuración, cuellos de botella de rendimiento y/o errores en la aplicación o plataforma. El paquete principal incluye soporte para entregar texto sin formato o XML registros de registro formateados en memoria, flujos de salida, consolas, archivos y sockets. Además, las API de registro son capaces de interactuar con los servicios de registro que ya existen en el sistema operativo host.

Paquete ^{java.útil.registro} " Proporciona las clases e interfaces de las instalaciones principales de registro de la plataforma Java.

Log4j 1.x " log4j es una popular utilidad de registro basada en Java. Log4j es un código abierto proyecto basado en el trabajo de muchos autores. Permite al desarrollador controlar qué instrucciones de registro se envían a una variedad de ubicaciones mediante el uso de Appenders [consola, archivos, base de datos y correo electrónico]. Es totalmente configurable en tiempo de ejecución utilizando archivos de configuración externos.

Log4j tiene tres componentes principales:

• Loggers - [OFF, FATAL, ERROR, WARN, INFO, DEBUG, TRACE]

• Appenders

  • Apache Commons Registro: ConsoleAppender, FileAppender, RollingFileAppender, DailyRollingFileAppender, JDBCAppender-Driver, SocketAppender

  • Log4J Adicionador de MongoDB: MongoDbAppender - Driver

• Layouts - [PatternLayout, EnhancedPatternLayout]

Los archivos de configuración se pueden escribir en XML o en formato Java properties (key=value).

1. log4j_External.propiedades " Java properties (key=value) format

La cadena entre una abertura "${" y cerrando "}" se interpreta como una clave. El valor de la variable sustituida se puede definir como una propiedad del sistema o en el propio archivo de configuración. Establecer opciones específicas de appender. "log4j. appender.Nombre de apéndice.opción = valor, Para cada appender con nombre puede configurar su Diseño.

log4j.rootLogger=INFO, FILE, FILE_PER_SIZE, FILE_PER_DAY, CONSOLE, MySql

#log.path=./
log.path=E:/Logs

# https://logging.apache.org/log4j/1.2/apidocs/org/apache/log4j/PatternLayout.html
# {%-5p - [WARN ,INFO ,ERROR], %5p 0- [ WARN, INFO,ERROR]}
log.patternLayout=org.apache.log4j.PatternLayout
log.pattern=%-5p - %d{yyyy-MM-dd HH:mm:ss.SSS} %C{1}:%12.20M:%L - %m %n

# System.out | System.err
log4j.appender.CONSOLE=org.apache.log4j.ConsoleAppender
log4j.appender.CONSOLE.Target=System.err
log4j.appender.CONSOLE.layout=${log.patternLayout}
log4j.appender.CONSOLE.layout.ConversionPattern=${log.pattern}

# File Appender
log4j.appender.FILE=org.apache.log4j.FileAppender
log4j.appender.FILE.File=${log.path}/logFile.log
#log4j:ERROR setFile(null,false) call failed. - Defaults setFile(null,true)
#log4j.appender.FILE.Append = false
log4j.appender.FILE.layout=${log.patternLayout}
log4j.appender.FILE.layout.ConversionPattern=${log.pattern}

# BackUP files for every Day.
log4j.appender.FILE_PER_DAY=org.apache.log4j.DailyRollingFileAppender
# [[ Current File ] - logRollingDayFile.log ], { [BackUPs] logRollingDayFile.log_2017-12-10, ... }
log4j.appender.FILE_PER_DAY.File=${log.path}/logRollingDayFile.log
log4j.appender.FILE_PER_DAY.DatePattern='_'yyyy-MM-dd
log4j.appender.FILE_PER_DAY.layout=${log.patternLayout}
log4j.appender.FILE_PER_DAY.layout.ConversionPattern=${log.pattern}

# BackUP files for size rotation with log cleanup.
log4j.appender.FILE_PER_SIZE=org.apache.log4j.RollingFileAppender
# [[ Current File ] - logRollingFile.log ], { [BackUPs] logRollingFile.log.1, logRollingFile.log.2}
log4j.appender.FILE_PER_SIZE.File=${log.path}/logRollingFile.log
log4j.appender.FILE_PER_SIZE.MaxFileSize=100KB
log4j.appender.FILE_PER_SIZE.MaxBackupIndex=2
log4j.appender.FILE_PER_SIZE.layout=${log.patternLayout}
log4j.appender.FILE_PER_SIZE.layout.ConversionPattern=${log.pattern}

# MySql Database - JDBCAppender
log4j.appender.MySql=org.apache.log4j.jdbc.JDBCAppender
log4j.appender.MySql.driver=com.mysql.jdbc.Driver
log4j.appender.MySql.URL=jdbc:mysql://localhost:3306/automationlab
log4j.appender.MySql.user=root
log4j.appender.MySql.password=
log4j.appender.MySql.layout=org.apache.log4j.EnhancedPatternLayout
log4j.appender.MySql.layout.ConversionPattern=INSERT INTO `logdata` VALUES ('%p', '%d{yyyy-MM-dd HH:mm:ss}', '%C', '%M', '%L', '%m');
#log4j.appender.MySql.sql=INSERT INTO `logdata` VALUES ('%p', '%d{yyyy-MM-dd HH:mm:ss}', '%C', '%M', '%L', '%m');

# Direct log events[Messages] to MongoDB Collection - MongoDbAppender
log.mongoDB.hostname=loalhost
log.mongoDB.userName=Yash777
log.mongoDB.password=Yash@123
log.mongoDB.DB=MyLogDB
log.mongoDB.Collection=Logs

log4j.appender.MongoDB=org.log4mongo.MongoDbAppender
log4j.appender.MongoDB.hostname=${log.mongoDB.hostname}
log4j.appender.MongoDB.userName=${log.mongoDB.userName}
log4j.appender.MongoDB.password=${log.mongoDB.password}
log4j.appender.MongoDB.port=27017
log4j.appender.MongoDB.databaseName=${log.mongoDB.DB}
log4j.appender.MongoDB.collectionName=${log.mongoDB.Collection}
log4j.appender.MongoDB.writeConcern=FSYNCED

Estructura de la tabla MySQL para el cuadro logdata

CREATE TABLE IF NOT EXISTS `logdata` (
  `Logger_Level` varchar(5) COLLATE utf8_unicode_ci NOT NULL,
  `DataTime` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
  `ClassName` varchar(30) COLLATE utf8_unicode_ci NOT NULL,
  `MethodName` varchar(50) COLLATE utf8_unicode_ci NOT NULL,
  `LineNumber` int(10) NOT NULL,
  `Message` text COLLATE utf8_unicode_ci NOT NULL
) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE=utf8_unicode_ci;

1. log4j_External.xml " XML log4j: configuración con archivo DTD público

<?xml version="1.0" encoding="iso-8859-1"?>
<!DOCTYPE log4j:configuration PUBLIC
  "-//APACHE//DTD LOG4J 1.2//EN" "http://logging.apache.org/log4j/1.2/apidocs/org/apache/log4j/xml/doc-files/log4j.dtd">
<log4j:configuration debug="false">

    <appender name="CONSOLE" class="org.apache.log4j.ConsoleAppender">
        <param name="target" value="System.out" />
        <param name="threshold" value="debug" />
        <layout class="org.apache.log4j.PatternLayout">
            <param name="ConversionPattern" value="%-5p - %d{yyyy-MM-dd HH:mm:ss.SSS} %C{1}:%12.20M:%L - %m %n" />
        </layout>
    </appender>

    <appender name="FILE" class="org.apache.log4j.FileAppender">
        <param name="file" value="E:/Logs/logFile.log" />
        <param name="append" value="false" />
        <layout class="org.apache.log4j.PatternLayout">
            <param name="ConversionPattern" value="%-5p - %d{yyyy-MM-dd HH:mm:ss.SSS} %C{1}:%12.20M:%L - %m %n" />
        </layout>
    </appender>

    <appender name="FILE_PER_SIZE" class="org.apache.log4j.RollingFileAppender">
        <param name="file" value="E:/Logs/logRollingFile.log" />
        <param name="immediateFlush" value="true"/>
        <param name="maxFileSize" value="100KB" />
        <param name="maxBackupIndex" value="2"/>
        <layout class="org.apache.log4j.PatternLayout">
            <param name="ConversionPattern" value="%-5p - %d{yyyy-MM-dd HH:mm:ss.SSS} %C{1}:%12.20M:%L - %m %n" />
        </layout>
    </appender>

    <appender name="FILE_PER_DAY" class="org.apache.log4j.DailyRollingFileAppender">
        <param name="file" value="E:/Logs/logRollingDayFile.log" />
        <param name="datePattern" value="'_'yyyy-MM-dd" />
        <layout class="org.apache.log4j.PatternLayout">
            <param name="ConversionPattern" value="%-5p - %d{yyyy-MM-dd HH:mm:ss.SSS} %C{1}:%12.20M:%L - %m %n"/>
        </layout>
    </appender>

    <root>
        <priority value="info" />
        <appender-ref ref="CONSOLE" />
        <appender-ref ref="FILE" />
        <appender-ref ref="FILE_PER_SIZE" />
        <appender-ref ref="FILE_PER_DAY" />
    </root>
</log4j:configuration>

1. Configuración Log4j desde la URL en el programa Java:

Para especificar una configuración personalizada con un archivo externo, la clase utilizada debe implementar Interfaz del configurador.

Cuando los archivos de configuración por defecto "log4j.properties"," log4j.xml" no están disponibles

• Para "log4j. properties" puede alimentar a la Configurador de propiedades.configure (java.net.URL) método.
• Para "log4j.xml" DOMConfigurator va a ser utilizado.

public class LogFiles {
    // Define a static logger variable so that it references the Logger instance named "LogFiles".
    static final Logger log = Logger.getLogger( LogFiles.class );

    @SuppressWarnings("deprecation")
    public static void main(String[] args) {
        System.out.println("CONFIGURATION_FILE « "+LogManager.DEFAULT_CONFIGURATION_FILE);
        System.out.println("DEFAULT_XML_CONFIGURATION_FILE = 'log4j.xml' « Default access modifier");

        String fileName = //"";
                //"log4j_External.xml";
                "log4j_External.properties";
        String configurationFile = System.getProperty("user.dir")+"/src/" + fileName;

        if( fileName.contains(".xml") ) {
            DOMConfigurator.configure( configurationFile );
            log.info("Extension *.xml");
        } else if ( fileName.contains(".properties") ) {
            PropertyConfigurator.configure( configurationFile );
            log.info("Extension *.properties");
        } else {
            DailyRollingFileAppender dailyRollingAppender = new DailyRollingFileAppender();
            dailyRollingAppender.setFile("E:/Logs/logRollingDayFile.log");
            dailyRollingAppender.setDatePattern("'_'yyyy-MM-dd");

            PatternLayout layout = new PatternLayout();
            layout.setConversionPattern( "%-5p - %d{yyyy-MM-dd HH:mm:ss.SSS} %C{1}:%12.20M:%L - %m %n" );
            dailyRollingAppender.setLayout(layout);

            dailyRollingAppender.activateOptions();

            Logger rootLogger = Logger.getRootLogger();
            rootLogger.setLevel(Level.DEBUG);
            rootLogger.addAppender(dailyRollingAppender);

            log.info("Configuring from Java Class.");
        }

        log.info("Console.Message.");
        method2();
        methodException(0);
    }

    static void method2() {
        log.info("method2 - Console.Message.");
    }
    static void methodException(int b) {
        try {
            int a = 10/b;
            System.out.println("Result : "+ a);
            log.info("Result : "+ a);
        } catch (Exception ex) { // ArithmeticException: / by zero
            log.error(String.format("\n\tException occurred: %s", stackTraceToString(ex)));
        }
    }
    public static String stackTraceToString(Exception ex) {
        StringWriter sw = new StringWriter();
        PrintWriter pw = new PrintWriter(sw);
        ex.printStackTrace(pw);
        return sw.toString();
    }
}

Si estamos usando apache commons logging wrapper encima de log4j, entonces necesitamos tener ambos jars disponibles en classpath. Además, commons-logging.properties y log4j.properties/xml deberían estar disponibles en classpath.

También podemos pasar la clase de implementación y el nombre log4j.properties como JAVA_OPTS usando -Dorg.apache.commons.logging.Log=<logging implementation class name> -Dlog4j.configuration=<file:location of log4j.properties/xml file>. Lo mismo se puede hacer a través de la configuración JAVA_OPTS en el caso de la aplicación/servidor web.

Ayudará a externalizar las propiedades que se pueden cambiar en el despliegue.

Esta es una forma alternativa de usar .yaml

Estructura lógica:

Configuration:
    Properties:
    Appenders:
    Loggers:

Muestra:

Configutation:
    name: Default

    Properties:
        Property:
            name: log-path
            value: "logs"

    Appenders:

        Console:
        name: Console_Appender
        target: SYSTEM_OUT
        PatternLayout:
            pattern: "[%-5level] %d{yyyy-MM-dd HH:mm:ss.SSS} [%t] %c{1} - %msg%n"

       File:
          name: File_Appender
          fileName: ${log-path}/logfile.log
          PatternLayout:
            pattern: "[%-5level] %d{yyyy-MM-dd HH:mm:ss.SSS} [%t] %c{1} - %msg%n"

    Loggers:

        Root:
            level: debug
            AppenderRef:
              - ref: Console_Appender

        Logger:
            - name: <package>.<subpackage>.<subsubpackage>.<...>
              level: debug
              AppenderRef:
                 - ref: File_Appender
                 level: error             

Ref: LOG4J 2 CONFIGURACIÓN: USANDO YAML

Para probar, una forma rápida y sucia que incluye establecer el nivel de registro:

org.apache.log4j.BasicConfigurator.configure();
org.apache.log4j.Logger.getRootLogger().setLevel(org.apache.log4j.Level.WARN);

// set to Level.DEBUG for full, or Level.OFF..