¿Cómo inicializar log4j correctamente?

Después de agregar log4j a mi aplicación, obtengo el siguiente resultado cada vez que ejecuto mi aplicación:

log4j: WARN No se encontraron apéndices para logger (slideselector.facedata.FaceDataParser).
log4j: WARN Inicialice el sistema log4j correctamente.

Parece que esto significa que falta un archivo de configuración. ¿Dónde debe ubicarse este archivo de configuración y cuál es un buen contenido de inicio?

Estoy usando Java simple para desarrollar una aplicación de escritorio. Así que no hay servidor web, etc.

Log4jpor defecto busca un archivo llamado log4j.propertieso log4j.xmlen el classpath.

Puede controlar qué archivo usa para inicializarse configurando las propiedades del sistema como se describe aquí (busque la sección "Procedimiento de inicialización predeterminado").

Por ejemplo:

java -Dlog4j.configuration=customName ....

Hará log4jque busque un archivo llamado customName en el classpath.

Si tiene problemas, me resulta útil activar log4j.debug:

-Dlog4j.debug

Imprimirá en System.out mucha información útil sobre qué archivo utilizó para inicializarse, qué registradores / anexores se configuraron y cómo, etc.

El archivo de configuración puede ser un archivo de propiedades java o un archivo xml. Aquí hay una muestra del formato de archivo de propiedades tomado de la página de documentación de introducción de log4j :

log4j.rootLogger=debug, stdout, R

log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout

# Pattern to output the caller's file name and line number.
log4j.appender.stdout.layout.ConversionPattern=%5p [%t] (%F:%L) - %m%n

log4j.appender.R=org.apache.log4j.RollingFileAppender
log4j.appender.R.File=example.log

log4j.appender.R.MaxFileSize=100KB
# Keep one backup file
log4j.appender.R.MaxBackupIndex=1

log4j.appender.R.layout=org.apache.log4j.PatternLayout
log4j.appender.R.layout.ConversionPattern=%p %t %c - %m%n

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 acaba de deshacerse de todo (por ejemplo, si está en pruebas)

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

Según la página de preguntas frecuentes de Apache Log4j :

¿Por qué veo una advertencia sobre "No se encontraron apéndices para el registrador" y "Configure log4j correctamente"?

Esto ocurre cuando la configuración predeterminada de archivos log4j.propertiesy log4j.xmlno puede ser encontrado y las lleva a cabo la aplicación necesita ninguna configuración explícita. log4jutiliza Thread.getContextClassLoader().getResource()para localizar los archivos de configuración predeterminados y no verifica directamente el sistema de archivos. Conocer la ubicación adecuada para colocar log4j.properties o log4j.xmlrequiere comprender la estrategia de búsqueda del cargador de clases en uso. log4jno 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 encontraron apéndices para el registrador significa que está utilizando el log4jsistema de registro, pero no ha agregado Apéndices (como FileAppender, ConsoleAppender, SocketAppender, SyslogAppender, etc.) en su archivo de configuración o el archivo de configuración está desaparecido.

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

log4j.properties

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

classpath

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

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

Gato

Si está utilizando Tomcat, puede colocar su log4j.propertiesen: /usr/share/tomcat?/lib/o /var/lib/tomcat?/webapps/*/WEB-INF/lib/carpeta.

Solr

Para la referencia, el log4j.propertiesarchivo predeterminado de Solr se ve así:

#  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: las clases log4j y el archivo de propiedades no están dentro del alcance del mismo cargador de clases.

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

Entonces, si tiene problemas, intente cargar la clase o el recurso usted mismo. Si no puede encontrarlo, tampoco lo hará log4j. ;)

Ver también:

• Breve introducción a log4j en el sitio de Apache
• Apache: Servicios de registro: preguntas más frecuentes en el sitio de Apache

Puede establecer la ubicación de su log4j.properties desde el interior de su aplicación Java utilizando:

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

Encuentre un log4j.properties o log4j.xml en línea que tenga un apéndice raíz y póngalo 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

iniciará sesión en 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 aplicaciones de registro detallado, 100 KB generalmente necesita incrementarse a 1 MB o 10 MB, 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.

Otra forma de hacerlo sin poner el archivo de propiedades en el classpath es establecer la propiedad directamente desde el código de Java. 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 utilizando setLevel () .

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

Por ejemplo:

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

El conjunto de niveles posibles son:

RASTRO,

DEPURAR,

INFORMACIÓN

ADVERTIR,

ERROR y

FATAL

Según el manual de servicios de registro

import org.apache.log4j.BasicConfigurator;

Llamar 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_OPTIONSen -Dlog4j.debug.

¿En qué te 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 solucionó con el siguiente 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

Creé el archivo log4j.properties en la carpeta de recursos junto al archivo hibernate.cfg.xml y lo rellené con el texto a continuación:

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 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 su archivo. Lo siguiente 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 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:

Al tomar el segundo enfoque, debe asegurarse de inicializar el archivo correctamente.

P.ej.

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 requerida para almacenar archivos de registro.

Intente establecer el atributo de depuración en log4j: nodo de configuración en verdadero.

<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 usa para configurar el entorno log4j. Es posible que reciba más detalles para resolver su problema.

Registro de API - El Java API de registro facilita software de servicio y mantenimiento en sitios de clientes mediante la producción de informes de registro adecuados para el análisis de los usuarios finales, administradores de sistemas, ingenieros de servicio de campo, y los equipos de desarrollo de software. Las API de registro capturan información como fallas 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 registros de registro en formato de texto plano o XML a la 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.util.logging} «Proporciona las clases e interfaces de los recursos de registro de la plataforma Java.

Log4j 1.x «log4j es una popular utilidad de registro basada en Java. Log4j es un proyecto de código abierto basado en el trabajo de muchos autores. Permite al desarrollador controlar qué declaraciones de registro se envían a una variedad de ubicaciones mediante 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:

• Registradores - [APAGADO, FATAL, ERROR, ADVERTENCIA, INFORMACIÓN, DEPURACIÓN, RASTREO]

• Apenders

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

  • Log4J Appender para MongoDB: MongoDbAppender -Driver

• Diseños: [PatternLayout, EnhancedPatternLayout]

Los archivos de configuración se pueden escribir en XML o en formato de propiedades Java (clave = valor).

1. log4j_External.properties «Formato de propiedades Java (clave = valor)

La cadena entre una apertura " $ { " y un cierre " } " se interpreta como una clave. El valor de la variable sustituida se puede definir como una propiedad del sistema o en el archivo de configuración en sí. Establecer las opciones específicas del apéndice. «Log4j.appender.appenderName.option = value, para cada apéndice nombrado 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 tabla MySQL para tabla 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;

2. 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>

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

Para especificar una configuración personalizada con un archivo externo, la clase utilizada debe implementar la interfaz Configurador .

cuando los archivos de configuración predeterminados "log4j.properties", "log4j.xml" no están disponibles

• Para "log4j.properties" puede alimentar el método PropertyConfigurator .configure (java.net.URL).
• Para "log4j.xml" se utilizará DOMConfigurator .

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();
    }
}

La solución para mí fue poner "log4j.properties" en la carpeta "src".

Si estamos utilizando el contenedor de registro de apache commons en la parte superior de log4j, entonces necesitamos tener ambos jar disponibles en classpath. Además, commons-logging.propertiesy log4j.properties/xmldebería estar disponible en classpath.

También podemos pasar la clase de implementación y el log4j.propertiesnombre ya JAVA_OPTSsea ​​usando -Dorg.apache.commons.logging.Log=<logging implementation class name> -Dlog4j.configuration=<file:location of log4j.properties/xml file>. Lo mismo se puede hacer mediante la configuración JAVA_OPTSen el caso de la aplicación / servidor web.

Ayudará a externalizar las propiedades que se pueden cambiar en la implementación.

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 las pruebas, 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..

Solución Maven:

Encontré los mismos problemas que antes, y para una solución maven usé 2 dependencias. Esta configuración solo está pensada para pruebas rápidas si desea que un proyecto simple use un registrador, con una configuración estándar. Me imagino que desea hacer un archivo de configuración más adelante si necesita más información o ajustar sus propios niveles de registro.

    <properties>
        <slf4jVersion>1.7.28</slf4jVersion>
    </properties>

        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-api</artifactId>
            <version>${slf4jVersion}</version>
        </dependency>
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-jdk14</artifactId>
            <version>${slf4jVersion}</version>
        </dependency>

Acabo de hacer esto y se solucionó el problema.

Seguido el siguiente blog

https://intellij-support.jetbrains.com/hc/en-us/community/posts/206875685-How-to-fix-log4j-WARN-console-messages-when-running-an-Application-inside-IntelliJ- Idea

Pero aquí dice como abajo

Para solucionarlo, simplemente ingrese el siguiente archivo log4j.resources en la carpeta main / resources de su proyecto

en lugar de crear log4j.resources, cree log4j.properties. Haga clic derecho en Recurso en IntelliJ -> Nuevo -> Paquete de recursos - Solo nómbrelo como log4j

Si tiene este error en Intellij IDEA incluso después de agregar el archivo log4j.propertieso log4j.xmlen su carpeta de prueba de recursos, tal vez Intellij IDEA aún no esté al tanto de la existencia del archivo.

Entonces, después de agregar el archivo, haga clic derecho en el archivo y elija Recompilar log4j.xml .